Cómo extender OpenClaw con Plugins

A veces instalas una herramienta y te das cuenta de que le falta justo esa integración específica que necesitas para tu flujo de trabajo. O quizás prefieres mantener tu instalación ligera sin funciones que no vas a usar a diario. Los plugins resuelven esto permitiéndote añadir capacidades extra solo cuando las necesitas.

Un plugin en OpenClaw es un pequeño módulo de código que extiende el sistema con comandos, herramientas para agentes y funciones de Gateway RPC.

Requisitos previos

Una instancia de OpenClaw instalada.
Acceso a la CLI de OpenClaw.
Archivo de configuración del Gateway accesible para edición.

Inicio rápido

Si eres nuevo en el uso de plugins, puedes tener uno funcionando en menos de 5 minutos siguiendo estos pasos:

Revisa qué plugins tienes cargados actualmente:

openclaw plugins list

Instala un plugin oficial (usaremos Voice Call como ejemplo):

openclaw plugins install @openclaw/voice-call

Reinicia el Gateway. Después, configura el plugin en la sección plugins.entries.<id>.config de tu archivo de configuración.

Puedes ver un ejemplo real en la documentación de Voice Call.

Detalles técnicos y capacidades

Los plugins de OpenClaw son módulos de TypeScript que se cargan en tiempo de ejecución mediante jiti. Un punto importante es que la validación de la configuración no ejecuta el código del plugin; en su lugar, utiliza el manifest del plugin y JSON Schema.

Debes tener en cuenta que los plugins se ejecutan en el mismo proceso (in-process) que el Gateway, por lo que debes usarlos como código de confianza. Estos módulos pueden registrar:

Métodos Gateway RPC y manejadores HTTP.
Herramientas para agentes (Agent tools).
Comandos de la CLI y servicios en segundo plano.
Skills y comandos de auto-respuesta que se ejecutan sin invocar al agente de AI.

Plugins oficiales disponibles

Microsoft Teams: Desde la versión 2026.1.15 es necesario instalar @openclaw/msteams si usas esta plataforma.
Memory (Core): Plugin de búsqueda de memoria integrado (activo por defecto).
Memory (LanceDB): Plugin de memoria a largo plazo. Se activa configurando plugins.slots.memory = "memory-lancedb".
Canales y Voz: Incluye @openclaw/voice-call, @openclaw/zalouser, @openclaw/matrix, @openclaw/nostr y @openclaw/zalo.
OAuth Providers: Plugins integrados como google-antigravity-auth, google-gemini-cli-auth y qwen-portal-auth (desactivados por defecto).
Copilot Proxy: Puente local para VS Code Copilot Proxy.

Runtime helpers

Si estás desarrollando un plugin, puedes acceder a utilidades del núcleo mediante api.runtime. Por ejemplo, para usar TTS (Text-to-Speech) en telefonía:

const result = await api.runtime.tts.textToSpeechTelephony({
  text: "Hello from OpenClaw",
  cfg: api.config,
});

Este helper utiliza la configuración de messages.tts (OpenAI o ElevenLabs) y devuelve un buffer de audio PCM.

Solución de problemas

Error en la validación de configuración: Recuerda que OpenClaw usa el manifest y JSON Schema para validar los datos sin ejecutar el código del plugin. Revisa que tu archivo plugins.entries.<id>.config coincida con el esquema definido en el Plugin manifest.
Audio en telefonía: Si el audio no funciona, verifica tu proveedor. Edge TTS no es compatible con las funciones de telefonía; debes usar OpenAI o ElevenLabs. Los plugins son responsables de re-codificar el buffer PCM si el proveedor lo requiere.

Si necesitas ayuda específica para configurar un plugin, puedes consultar al AI Setup Assistant.

Próximos pasos

¿Te ha pasado que instalas una extensión y parece que el sistema simplemente la ignora? Gestionar plugins puede ser un dolor de cabeza cuando no sabes exactamente dónde los está buscando tu herramienta. Entender el orden de prioridad te ayuda a evitar conflictos y a asegurar que OpenClaw use siempre la versión correcta de tu código.

Configurar tus extensiones de forma correcta te ahorrará tiempo depurando por qué un cambio no aparece en tu entorno. Aquí tienes todo lo necesario para dominar el sistema de descubrimiento.

Requisitos previos

Tener OpenClaw instalado en tu sistema.
Un archivo openclaw.plugin.json para cada plugin.
Node.js y un gestor de paquetes (npm o pnpm) si usas dependencias externas.
Acceso a la terminal para ejecutar comandos CLI.

Inicio rápido

OpenClaw escanea las rutas en un orden estricto. Si dos plugins tienen el mismo ID, el primero que se encuentre en esta lista tiene prioridad y los demás se ignoran:

Config paths: Rutas definidas en plugins.load.paths (puede ser un archivo o un directorio).
Workspace extensions:
- <workspace>/.openclaw/extensions/*.ts
- <workspace>/.openclaw/extensions/*/index.ts
Global extensions:
- ~/.openclaw/extensions/*.ts
- ~/.openclaw/extensions/*/index.ts
Bundled extensions: Plugins que vienen con OpenClaw (están desactivados por defecto).
- <openclaw>/extensions/*

Para activar los plugins integrados (bundled), usa el comando openclaw plugins enable <id> o configúralo en plugins.entries.<id>.enabled. Los plugins que instales tú manualmente se activan por defecto.

Package packs

Si quieres agrupar varias extensiones, puedes incluir un package.json en el directorio del plugin con la propiedad openclaw.extensions:

{
  "name": "my-pack",
  "openclaw": {
    "extensions": ["./src/safety.ts", "./src/tools.ts"]
  }
}

Cada entrada se convierte en un plugin independiente. En este caso, el ID del plugin será name/fileBase. Si usas dependencias de npm, asegúrate de instalarlas en ese directorio para que node_modules esté disponible mediante npm install o pnpm install.

Channel catalog metadata

Los plugins de canales pueden incluir metadatos para el onboarding y pistas de instalación. Esto permite que el core de OpenClaw se mantenga ligero y sin datos innecesarios.

Ejemplo:

{
  "name": "@openclaw/nextcloud-talk",
  "openclaw": {
    "extensions": ["./index.ts"],
    "channel": {
      "id": "nextcloud-talk",
      "label": "Nextcloud Talk",
      "selectionLabel": "Nextcloud Talk (self-hosted)",
      "docsPath": "/channels/nextcloud-talk",
      "docsLabel": "nextcloud-talk",
      "blurb": "Self-hosted chat via Nextcloud Talk webhook bots.",
      "order": 65,
      "aliases": ["nc-talk", "nc"]
    },
    "install": {
      "npmSpec": "@openclaw/nextcloud-talk",
      "localPath": "extensions/nextcloud-talk",
      "defaultChoice": "npm"
    }
  }
}

OpenClaw también puede fusionar catálogos de canales externos. Puedes colocar un archivo JSON en cualquiera de estas rutas:

~/.openclaw/mpm/plugins.json
~/.openclaw/mpm/catalog.json
~/.openclaw/plugins/catalog.json

Si prefieres usar variables de entorno, apunta OPENCLAW_PLUGIN_CATALOG_PATHS (o OPENCLAW_MPM_CATALOG_PATHS) a uno o más archivos JSON separados por comas o puntos y coma. El formato del archivo debe ser: { "entries": [ { "name": "@scope/pkg", "openclaw": { "channel": {...}, "install": {...} } } ] }.

Solución de problemas

El plugin no se reconoce: Asegúrate de que el archivo openclaw.plugin.json esté en la raíz del plugin. Si la ruta apunta a un archivo específico, la raíz es el directorio donde se encuentra ese archivo.
Conflictos de ID: Recuerda que la prioridad sigue el orden de escaneo. Si tienes un plugin en el Workspace y otro Global con el mismo ID, OpenClaw cargará el del Workspace.
Plugins integrados no funcionan: Estos están desactivados por defecto. Debes habilitarlos explícitamente mediante la configuración o el CLI.
Dependencias no encontradas: Si tu plugin usa paquetes externos, verifica que hayas ejecutado npm install dentro del directorio del plugin para generar el node_modules local.

¿Necesitas ayuda para configurar tus plugins? Prueba nuestro AI Setup Assistant.

Próximos pasos

Seguro que te ha pasado: quieres extender una herramienta y terminas peleando con archivos de configuración infinitos o IDs que no coinciden. Gestionar extensiones no debería ser un proceso adivinatorio ni romper tu flujo de trabajo cada vez que añades una funcionalidad nueva.

OpenClaw utiliza un sistema de plugins diseñado para ser predecible. Aquí te explico cómo configurarlos y sacarles partido sin complicaciones.

Requisitos previos

OpenClaw instalado y funcionando.
Un archivo de configuración (normalmente openclaw.config.json5).
Acceso a la terminal para ejecutar comandos de la CLI.

Inicio rápido

Configura tu primer plugin en menos de 5 minutos siguiendo estos pasos:

Identifica el Plugin ID: Si es un paquete, usa el name de su package.json. Si es un archivo suelto, usa el nombre base (ej. voice-call.ts es voice-call).
Modifica la configuración: Añade el ID a la sección plugins de tu archivo de configuración.
Reinicia el Gateway: Los cambios en la configuración requieren un reinicio completo para aplicarse.
Verifica el estado: Ejecuta openclaw plugins list para confirmar que está activo.

Plugin IDs

OpenClaw asigna IDs de forma automática para que no tengas que inventarlos:

Packs de Node.js: Utiliza el campo name en el package.json.
Archivos independientes: Utiliza el nombre base del archivo (ejemplo: ~/.../voice-call.ts se convierte en voice-call).

Si un plugin exporta explícitamente un id, OpenClaw lo usará, pero te mostrará un aviso si no coincide con el ID configurado.

Configuración

Para gestionar tus plugins, edita tu archivo de configuración siguiendo esta estructura:

{
  plugins: {
    enabled: true,
    allow: ["voice-call"],
    deny: ["untrusted-plugin"],
    load: { paths: ["~/Projects/oss/voice-call-extension"] },
    entries: {
      "voice-call": { enabled: true, config: { provider: "twilio" } },
    },
  },
}

Campos disponibles:

enabled: Interruptor maestro (por defecto es true).
allow: Lista blanca opcional.
deny: Lista negra opcional (si un plugin está aquí, deny siempre gana).
load.paths: Rutas adicionales para buscar archivos o directorios de plugins.
entries.<id>: Configuración específica y activadores por plugin.

Importante: Cualquier cambio en estos campos requiere un Gateway restart.

Reglas de validación (estrictas):

Los IDs de plugins desconocidos en entries, allow, deny o slots generan errores.
Las claves desconocidas en channels.<id> generan errores, a menos que un manifiesto de plugin declare ese ID de canal.
La configuración del plugin se valida mediante el JSON Schema embebido en openclaw.plugin.json (configSchema).
Si desactivas un plugin, su configuración se mantiene pero el sistema emitirá un warning.

Plugin slots

Existen categorías de plugins que son exclusivas; esto significa que solo puede haber uno activo a la vez. Usa plugins.slots para elegir cuál debe tomar el control:

{
  plugins: {
    slots: {
      memory: "memory-core", // o usa "none" para desactivar plugins de memoria
    },
  },
}

Si varios plugins declaran kind: "memory", solo se cargará el que hayas seleccionado. Los demás se desactivarán y verás un mensaje de diagnóstico.

Control UI (schema + labels)

La Control UI utiliza config.schema (JSON Schema + uiHints) para generar formularios de configuración más claros.

OpenClaw mejora los uiHints en tiempo de ejecución basándose en los plugins detectados:

Añade etiquetas por plugin para plugins.entries.<id>, .enabled y .config.
Combina sugerencias de campos de configuración bajo: plugins.entries.<id>.config.<field>.

Si quieres que los campos de tu plugin muestren etiquetas correctas o marquen datos sensibles (como claves de API), incluye uiHints junto a tu JSON Schema en el manifiesto del plugin.

Ejemplo de manifiesto:

{
  "id": "my-plugin",
  "configSchema": {
    "type": "object",
    "additionalProperties": false,
    "properties": {
      "apiKey": { "type": "string" },
      "region": { "type": "string" }
    }
  },
  "uiHints": {
    "apiKey": { "label": "API Key", "sensitive": true },
    "region": { "label": "Region", "placeholder": "us-east-1" }
  }
}

CLI

La CLI de OpenClaw te permite gestionar todo el ciclo de vida de los plugins:

openclaw plugins list
openclaw plugins info <id>
openclaw plugins install <path>                 # Copia un archivo/dir local a ~/.openclaw/extensions/<id>
openclaw plugins install ./extensions/voice-call # Ruta relativa permitida
openclaw plugins install ./plugin.tgz           # Instala desde un tarball local
openclaw plugins install ./plugin.zip           # Instala desde un zip local
openclaw plugins install -l ./extensions/voice-call # Link (sin copia) para desarrollo
openclaw plugins install @openclaw/voice-call # Instala desde npm
openclaw plugins update <id>
openclaw plugins update --all
openclaw plugins enable <id>
openclaw plugins disable <id>
openclaw plugins doctor

Ten en cuenta que plugins update solo funciona para instalaciones de npm rastreadas en plugins.installs. Los plugins también pueden registrar sus propios comandos de primer nivel (ejemplo: openclaw voicecall).

Plugin API

Los plugins deben exportar uno de estos dos formatos:

Una función: (api) => { ... }
Un objeto: { id, name, configSchema, register(api) { ... } }

Plugin hooks

Los plugins pueden incluir hooks y registrarlos en tiempo de ejecución. Esto permite agrupar automatizaciones basadas en eventos sin necesidad de instalar un pack de hooks por separado.

Ejemplo de registro:

import { registerPluginHooksFromDir } from "openclaw/plugin-sdk";

export default function register(api) {
  registerPluginHooksFromDir(api, "./hooks");
}

Notas importantes:

Los directorios de hooks deben seguir la estructura estándar (HOOK.md + handler.ts).
Se aplican las reglas habituales de elegibilidad (requisitos de OS, binarios, entorno o configuración).
Los hooks gestionados por plugins aparecen en openclaw hooks list con el prefijo plugin:<id>.
No puedes activar o desactivar estos hooks individualmente mediante openclaw hooks; debes activar o desactivar el plugin completo.

Solución de problemas

Error de ID desconocido: Revisa que el ID en allow, deny o entries coincida exactamente con el nombre del paquete o el nombre base del archivo.
El plugin no carga: Verifica si el plugin pertenece a un slot exclusivo (como memory) y si está seleccionado en plugins.slots.
Error de validación de configuración: Comprueba que los valores en tu archivo de configuración cumplen con el configSchema definido por el plugin.
Cambios no aplicados: Asegúrate de haber reiniciado el Gateway tras modificar el archivo de configuración.

AI Setup Assistant

Próximos pasos

---
title: "Plugins de proveedor y autenticación de modelos en OpenClaw"
description: "Aprende a registrar flujos de OAuth, configurar canales de mensajería y añadir comandos personalizados usando la API de plugins de OpenClaw."
---

¿Te ha pasado que pierdes demasiado tiempo configurando la autenticación de un modelo o peleando con scripts externos solo para conectar una API? Es frustrante cuando quieres que tu herramienta funcione y te encuentras saltando entre pestañas para copiar tokens o manejar flujos de OAuth de forma manual.

OpenClaw elimina esta fricción permitiéndote integrar todo el proceso de autenticación y configuración directamente en el sistema. Puedes gestionar desde el login de los proveedores hasta la creación de nuevos canales de chat sin salir de tu flujo de trabajo habitual.

### What You'll Need

Para seguir esta guía, asegúrate de tener lo siguiente:

- Una instancia de OpenClaw instalada y configurada.
- Acceso a la API de plugins (`api`).

### Quick Start

Registrar un proveedor de modelos permite que los usuarios realicen el setup de OAuth o API keys directamente en OpenClaw. Solo necesitas usar `api.registerProvider(...)`.

Aquí tienes el ejemplo mínimo para un flujo de OAuth:

```ts
api.registerProvider({
  id: "acme",
  label: "AcmeAI",
  auth: [
    {
      id: "oauth",
      label: "OAuth",
      kind: "oauth",
      run: async (ctx) => {
        // Ejecuta el flujo OAuth y devuelve los perfiles de autenticación.
        return {
          profiles: [
            {
              profileId: "acme:default",
              credential: {
                type: "oauth",
                provider: "acme",
                access: "...",
                refresh: "...",
                expires: Date.now() + 3600 * 1000,
              },
            },
          ],
          defaultModel: "acme/opus-1",
        };
      },
    },
  ],
});

Una vez registrado, puedes usar este comando en la CLI: openclaw models auth login --provider acme --method oauth

Notas importantes:

La función run recibe un ProviderAuthContext con utilidades como prompter, runtime, openUrl y oauth.createVpsAwareHandlers.
Devuelve configPatch si necesitas añadir modelos por defecto o configuración del proveedor.
Devuelve defaultModel para que el flag --set-default pueda actualizar los valores del agente.

Registro de canales de mensajería

Si necesitas que OpenClaw funcione en una plataforma nueva (como un chat interno), puedes registrar un canal personalizado. La configuración se guarda bajo channels.<id>.

const myChannel = {
  id: "acmechat",
  meta: {
    id: "acmechat",
    label: "AcmeChat",
    selectionLabel: "AcmeChat (API)",
    docsPath: "/channels/acmechat",
    blurb: "demo channel plugin.",
    aliases: ["acme"],
  },
  capabilities: { chatTypes: ["direct"] },
  config: {
    listAccountIds: (cfg) => Object.keys(cfg.channels?.acmechat?.accounts ?? {}),
    resolveAccount: (cfg, accountId) =>
      cfg.channels?.acmechat?.accounts?.[accountId ?? "default"] ?? {
        accountId,
      },
  },
  outbound: {
    deliveryMode: "direct",
    sendText: async () => ({ ok: true }),
  },
};

export default function (api) {
  api.registerChannel({ plugin: myChannel });
}

Puntos clave:

Usa meta.label para los nombres en la CLI y la UI.
meta.aliases permite usar IDs alternativos en la CLI.
meta.preferOver sirve para omitir la activación automática de otros canales cuando ambos están configurados.
meta.detailLabel y meta.systemImage ayudan a que la UI muestre iconos y etiquetas más ricas.

Cómo crear un canal paso a paso

Sigue este orden cuando quieras añadir una nueva superficie de chat:

ID y configuración: Define un ID único. Toda la configuración debe vivir en channels.<id>. Usa channels.<id>.accounts.<accountId> para soportar múltiples cuentas.
Metadatos: Configura meta.label, meta.selectionLabel y meta.docsPath (que debe apuntar a una página como /channels/<id>).
Adaptadores obligatorios: Implementa config.listAccountIds, config.resolveAccount, capabilities y outbound.sendText.
Adaptadores opcionales: Añade setup (asistente), security (políticas de DM), status (diagnósticos) o gateway (control de inicio/parada).
Registro: Finaliza llamando a api.registerChannel({ plugin }).

Ejemplo de configuración mínima en JSON5:

{
  channels: {
    acmechat: {
      accounts: {
        default: { token: "ACME_TOKEN", enabled: true },
      },
    },
  },
}

Comandos de respuesta automática

Puedes registrar comandos de tipo slash (/) que se ejecutan sin llamar al agente de IA. Esto es ideal para consultar estados o realizar acciones rápidas.

export default function (api) {
  api.registerCommand({
    name: "mystatus",
    description: "Show plugin status",
    handler: (ctx) => ({
      text: `Plugin is running! Channel: ${ctx.channel}`,
    }),
  });
}

El handler recibe un contexto con:

senderId: ID de quien envía el mensaje.
channel: Canal donde se envió.
isAuthorizedSender: Si el usuario está autorizado.
args: Argumentos si acceptsArgs es true.
config: La configuración actual de OpenClaw.

Otros registros útiles

Métodos RPC del Gateway:

export default function (api) {
  api.registerGatewayMethod("myplugin.status", ({ respond }) => {
    respond(true, { ok: true });
  });
}

Comandos de la CLI:

export default function (api) {
  api.registerCli(
    ({ program }) => {
      program.command("mycmd").action(() => {
        console.log("Hello");
      });
    },
    { commands: ["mycmd"] },
  );
}

Servicios en segundo plano:

export default function (api) {
  api.registerService({
    id: "my-service",
    start: () => api.logger.info("ready"),
    stop: () => api.logger.info("bye"),
  });
}

Troubleshooting

Registro duplicado: Si dos plugins intentan registrar el mismo nombre de comando, el proceso fallará con un error de diagnóstico.
Comandos que no responden: Si envías argumentos a un comando que tiene acceptsArgs: false, el comando no coincidirá y el mensaje pasará a otros controladores.
Nombres de comandos: Deben empezar con una letra y solo pueden contener letras, números, guiones y guiones bajos.
Comandos reservados: No puedes sobrescribir comandos del sistema como help, status o reset.

¿Necesitas ayuda con la configuración? Prueba el AI Setup Assistant.

What’s Next

Plugin agent tools

Gestionar plugins puede ser un dolor de cabeza si no sigues una estructura clara desde el principio. No hay nada peor que un sistema donde cada herramienta se nombra de forma distinta o donde la configuración se vuelve impredecible.

Para que tu desarrollo sea fluido y evitar conflictos en el Gateway, te recomiendo seguir estas normas. Son las mismas que usamos en el core para que todo encaje sin fricciones.

## Requisitos previos

- Acceso al repositorio principal de `openclaw`.
- Node.js y npm instalados para la gestión de paquetes.
- Un plugin en desarrollo o la intención de crear uno nuevo.
- Entorno de pruebas con Vitest (si planeas incluir tests).

## Inicio rápido

1.  **Nombra tus componentes**: Usa `pluginId.action` para métodos (ej: `voicecall.status`) y `snake_case` para herramientas (ej: `voice_call`).
2.  **Configura el package.json**: Añade el campo `openclaw.extensions` apuntando a tus archivos de entrada.
3.  **Habilita el plugin**: En tu configuración, usa `plugins.entries.<id>.enabled: true`.
4.  **Instala vía CLI**: Ejecuta `openclaw plugins install <npm-spec>` para añadir plugins externos.

## Convenciones de nombres

Mantener la consistencia es vital para que otros desarrolladores entiendan tu código. Sigue este esquema:

- **Gateway methods**: Siempre usa el formato `pluginId.action`. Por ejemplo: `voicecall.status`.
- **Tools**: Usa `snake_case`. Por ejemplo: `voice_call`.
- **CLI commands**: Puedes usar `kebab-case` o `camelCase`, pero asegúrate de no chocar con los comandos principales del sistema.

## Skills

Los plugins pueden incluir una "skill" dentro del repositorio en la ruta `skills/<name>/SKILL.md`. Para activarla, usa la clave `plugins.entries.<id>.enabled` en tu configuración. Asegúrate de que el archivo esté presente en las ubicaciones de skills gestionadas de tu workspace.

## Distribución (npm)

Para organizar el código, te sugiero esta estructura de paquetes:

- **Paquete principal**: `openclaw`.
- **Plugins**: Paquetes npm separados bajo el scope `@openclaw/*` (ejemplo: `@openclaw/voice-call`).

Cuando publiques un plugin, el archivo `package.json` debe incluir obligatoriamente `openclaw.extensions` con uno o más archivos de entrada. Estos archivos pueden ser `.js` o `.ts`, ya que `jiti` se encarga de cargar TypeScript en tiempo de ejecución.

Un detalle importante: cuando instalas un paquete con scope, OpenClaw normaliza el ID al nombre **sin scope** para las claves en `plugins.entries.*`. El comando `openclaw plugins install <npm-spec>` usa `npm pack`, extrae el contenido en `~/.openclaw/extensions/<id>/` y lo habilita automáticamente.

## Ejemplo: Plugin Voice Call

En este repositorio tienes un ejemplo real con el plugin de llamadas de voz (que usa Twilio o un fallback de logs):

- **Source**: `extensions/voice-call`
- **Skill**: `skills/voice-call`
- **CLI**: `openclaw voicecall start|status`
- **Tool**: `voice_call`
- **RPC**: `voicecall.start`, `voicecall.status`

### Configuración
Si usas Twilio:
- `provider: "twilio"`
- `twilio.accountSid`, `twilio.authToken`, `twilio.from`
- Opcionales: `statusCallbackUrl`, `twimlUrl`

Si estás en desarrollo local:
- `provider: "log"` (no requiere red)

Puedes revisar más detalles en [Voice Call](/docs/tools/plugins/voice-call) y en el archivo `extensions/voice-call/README.md`.

## Notas de seguridad

Los plugins se ejecutan en el mismo proceso que el Gateway. Esto significa que debes tratarlos como código de total confianza:

- Instala solo plugins en los que confíes plenamente.
- Te sugiero usar allowlists mediante `plugins.allow`.
- Reinicia el Gateway siempre que realices cambios en los plugins.
- Revisa el código fuente antes de integrar extensiones de terceros.

## Testing

Es fundamental que tus plugins incluyan pruebas:

- **Plugins en el repo**: Mantén tus tests de Vitest en `src/**` (ejemplo: `src/plugins/voice-call.plugin.test.ts`).
- **Plugins externos**: Deben ejecutar su propio CI (lint, build y test). Verifica siempre que `openclaw.extensions` apunte al entrypoint ya compilado, como `dist/index.js`.

## Solución de problemas

- **El comando de la CLI no responde**: Revisa si el nombre choca con un comando core. Intenta cambiar el nombre en la configuración de la CLI del plugin.
- **El plugin no se carga tras la instalación**: Asegúrate de que el `package.json` tiene la propiedad `openclaw.extensions` correctamente definida.
- **Error de tipos en tiempo de ejecución**: Si usas archivos `.ts`, verifica que `jiti` tenga acceso a las dependencias necesarias.
- **La configuración no se aplica**: Recuerda que los paquetes con scope (como `@openclaw/plugin`) se configuran usando solo el ID base (`plugin`).

¿Necesitas ayuda para configurar tu entorno? Prueba nuestro [AI Setup Assistant](/docs/).

## Próximos pasos

- [Guía de configuración de Voice Call](/docs/tools/plugins/voice-call)
- [Referencia de la CLI](/docs/cli)
- [Arquitectura del Gateway](/docs/gateway)
- [Publicación en npm](/docs/publishing)

OpenClaw Expert

Sigues atascado?

Si esta pagina no resolvio tu caso, pregunta a OpenClaw Expert para pasos concretos.