yahboom
HomeTutorialsProduct
Solution
Blog
Online Store
About Us
EN/中文
Store
Jetson Orin NANO Developer Kit📖
01.Get started
  • 01. Learning route
  • 02. Get started quickly
  • 03. System Update Notes
  • 04. Disabling automatic updates and troubleshooting issues
  • 05. Jetson Orin Nano official kit screwdriver instructions
02.Jetson basic course
  • 01.Jetson board introduction
  • 02.Write Jetson original system
  • 03.Installing Jetson environment
  • 04.Backup SSD system
  • 05.Restore initial image system
  • 06.Upgrade to SUPER version (Optional)
  • 07.Write SUPER boot (Must read)
  • 08.SSD expansion
  • 09.Jetpack old system upgraded to Yahboom SUPER factory system
  • 10.Write the system onto your own SSD
03.Basic setting course
  • 01.Basic knowledge
  • 02.Network configuration
  • 03.SSH remote login
  • 04.VNC remote control
  • 05.RDP remote control
  • 06.Remote file transfer
  • 07.Jtop tool
  • 08.Exchange space expansion
  • 09.Use VSCode
  • 10.Use VMware
  • 11.Modify screen resolution
04.GPIO control course
  • 01.GPIO description
  • 02.GPIO library installation
  • 03.GPIO reading
  • 04.GPIO output
  • 05.Serial communication
  • 06.I2C communication
05.Vision basic course
  • 01.CSI camera preview
  • 02.USB camera preview
  • 03.Use Jupyter Lab
  • 04.Use JetCam
06.OpenCV basic course
  • 01.Image reading
  • 02.Image saving
  • 03.Image modification
  • 04.Image scaling
  • 05.Image cropping
  • 06.Image translation
  • 07.Image mirroring
  • 08.Image grayscale conversion
  • 09.Image binarization
  • 10.Image edge detection
  • 11.Add line segments
  • 12.Add rectangles
  • 13.Add circular shape
  • 14.Add ellipses
  • 15.Add polygons
  • 16.Add Text
  • 17.Preview USB camera image
  • 18.Preview CSI camera image
07.Vision advanced course
01.Environment construction
  • 01.TensorFlow
  • 02.PyTorch
  • 03.Torchvision
02.DeepStream development
  • 01.DeepStream environment
  • 02.License plate detection and recognition
  • 03.Parallel multi-model inference
  • 04.Object embedding vector generation
  • 05.Pose recognition
  • 06.NV optical flow anomaly detection
  • 07.Single-view 3D tracking
  • 08.Multi-view 3D tracking
03.NVIDIA TAO toolkit application
  • 01.Traffic scene object detection
  • 02.Person object detection
  • 03.Vehicle brand classification
  • 04.Vehicle model classification
  • 05.License plate detection and recognition
  • 06.Person semantic segmentation
  • 07.Retail product detection and recognition
  • 08.Person feature extraction and matching (ReID)
  • 09.Person action and pose classification
  • 10.Transformer-based person detection
  • 11.3D human skeleton detection
  • 12.LiDAR 3D point cloud detection
04.YOLO11 development
  • 01.YOLO environment construction
  • 02.CLI use
  • 03.Object detection
  • 04.Instance segmentation
  • 05.Pose estimation
  • 06.Image classification
  • 07.Oriented object detection
  • 08.Model conversion
  • 09.Dataset annotation
  • 10.Model training conversion
  • 11.Model prediction
05.Mediapipe development
  • 01.Mediapipe environment
  • 02.Hand detection
  • 03.Face detection
  • 04.Face effects
  • 05.3D object recognition
  • 06.Virtual brush
  • 07.Gesture recognition
  • 08.Finger control
  • 09.Posture estimation
  • 10.Face mask
  • 11.Overall detection
  • 12.Green scene removal(Human)
06.YOLO26 development
  • 01.YOLO environment construction
  • 02.CLI use
  • 03.Object detection
  • 04.Instance segmentation
  • 05.Pose estimation
  • 06.Image classification
  • 07.Oriented object detection
  • 08.Model conversion
  • 09.Dataset annotation
  • 10.Model training conversion
  • 11.Model prediction
07.QR code recognition
  • QR code recognition
08.Docker basic course
  • 01.Docker introduction
  • 02.Docker installation
  • 03.Docker command
  • 04.Docker usage
  • 05.Docker interaction
09.ROS2-Jazzy
01.ROS2 basic course
  • 1.Introduction to ROS2
  • 2.ROS2 install Jazzy
  • 3.ROS2 development environment
  • 4.ROS2 workspace
  • 5.ROS2 function package
  • 6.ROS2 node
  • 7.ROS2 topic communication
  • 8.ROS2 service communication
  • 9.ROS2 action communication
  • 10.ROS2 custom interface message
  • 11.ROS2 parameter service case
  • 12.ROS2 meta-function package
  • 13.ROS2 distributed communication
  • 14.ROS2 DDS
  • 15.ROS2 time related API
  • 16.ROS2 common command tools
  • 17.ROS2 rviz2 use
  • 18.ROS2 rqt toolbox
  • 19.ROS2 Launch startup file configuration
  • 20.ROS2 recording and playback tool
  • 21.ROS2 URDF model
  • 22.ROS2 Gazebo simulation platform
  • 23.ROS2 TF2 coordinate transformation
02.ROS2 vision course
  • 01.Camera preview (USB)
  • 02.Camera preview (CSI)
  • 03.Camera calibration (USB)
  • 04.Camera calibration (CSI)
  • 05.AR vision (USB)
  • 06.AR vision (CSI)
10.Large model basic course
01.Offline large model
  • 01.AI large model environment deployment
  • 02.Install large model dialogue platform
  • 03.Meta AI - Llama model
  • 04.Alibaba Cloud - Qwen model
  • 05.Microsoft - Phi-4-mini model
  • 06.DeepSeek - DeepSeek model
  • 07.Alibaba Cloud - Qwen-VL visual multimodal large model
  • 08.Google - Gemma visual multimodal large model
  • 9.Llava visual multimodal large model
  • 10.MiniCPM-V visual multimodal large model
  • 11.High-quality vision-language grounding (LocateAnything)
02.Online large model
  • 01.Tongyi Qianwen large model
  • 02.OpenRouter large model API aggregation platform
11.Large model application practice
01.Voice interaction application
  • 1.Voice interaction hardware connection (Must read)
  • 2.Offline speech to text (ASR)
  • 3.Offline text to speech (TTS)
  • 4.AI large model voice interaction
  • 5.AI large model offline voice assistant
02.Multimodal large model application (Online_Offline large model + Text_Voice interaction)
  • 01.Multimodal visual understand application
  • 02.Multimodal text image application
  • 03.Multimodal video analysis application
  • 04.Multi module visual position application
  • 05.Multimodal table scanning application
  • 06.Multimodal autonomous agent application
12.NVIDIA Isaac ROS course
  • 01.Build Isaac ROS environment
  • 02.Deep segmentation
  • 03.DNN stereoscopic depth
  • 04.Free space segmentation
  • 05.Image distortion processing
  • 06.Image segmentation
  • 07.3D scene reconstruction and mapping
  • 08.Object detection
  • 09.3D attitude estimation
  • 10.Visual SLAM
13.OpenClaw deployment and basic usage
01.OpenClaw deployment and introduction
  • 01.Quick start with the pre-configured environment (Recommended)
  • 02.OpenClaw Deployment
  • 03.OpenClaw WhatsApp Plugin Application
  • 04.OpenClaw WebChat Interaction
  • 05.OpenClaw TUI Interaction
  • 06.OpenClaw Tools Introduction
  • 07.OpenClawGate Gateway User Manual
  • 08.OpenClaw Features Overview
  • 09.OpenClawHub Introduction (Skill Installation)
02.OpenClaw basic application
  • 01.OpenClaw Application - File Management
  • 02.OpenClaw Application - Camera
  • 03.OpenClaw Application - Browser Control
  • 04.OpenClaw Application - Script Execution
  • 05.OpenClaw Application - AI Programming (Peripheral & GPIO Control)
  • 06.OpenClaw Application - Dedicated AI Assistant
  • 07.OpenClaw Web Search Capability Configuration
03.NVIDIA official Agent Skills application
  • 01.AI-assisted development with VS Code or Cursor
  • 02.Jetson device skills
  • 03.Jetson BSP custom agent skills
14.OpenClaw advanced development
01.Preparation Before Use
  • 01.Peripheral Hardware Configuration
  • 02.OpenClaw API-KEY Configuration
  • 03.OpenClaw Model Switching
  • 04.OpenClaw Prompts
  • 05.AI Voice Interaction Configuration
  • 06.Three Dialogue Configuration Tests
02.OpenClaw AI Programming Peripheral Control
  • 1. Servo Control
  • 2. RGB Strip
  • 3. OLED Display
  • 4. Temperature and Humidity Sensor
  • 5. Camera Application
  • 6. AI Script Peripheral Control
03.OpenClaw Peripheral Integration Applications
  • 1. Plant Care Assistant
  • 2. AI Calorie Estimation
  • 3. AI Rock Paper Scissors Game
  • 4. AI Pet
  • 5. AI Weather Station
  • 6. Temperature Humidity Dashboard
  • 7. Scheduled Tasks
Download
  • System_File
  • VMFile_BootFile
  • 3D Model File
  • DataSheet
  • Software_Tools
  • Code
  • Manual
Download ZIP

Welcome to Jetson Orin NANO Developer Kit repository

08.OpenClaw Features Overview

Plugins

Quick Start

A plugin is just a small code module that extends OpenClaw with additional functionality (commands, tools, and Gateway RPC). Most of the time, you use plugins when you want a feature that is not yet built into core OpenClaw (or you want to keep optional features out of the main installation). Quick path:

  1. Check what is loaded:

openclaw plugins list
  1. Install an official plugin (for example: Voice Call):

xxxxxxxxxx
openclaw plugins install @openclaw/voice-call
  1. Restart the Gateway, then configure it under plugins.entries.<id>.config.

 

Available Plugins (Official)

  • Starting from 2026.1.15, Microsoft Teams is provided only as a plugin; if you use Teams, install @openclaw/msteams.

  • Memory (Core) — the bundled memory search plugin (enabled by default via plugins.slots.memory)

  • Memory (LanceDB) — the bundled long-term memory plugin (automatic recall/capture; set plugins.slots.memory = "memory-lancedb")

  • Voice Call — @openclaw/voice-call

  • Zalo Personal — @openclaw/zalouser

  • Matrix — @openclaw/matrix

  • Nostr — @openclaw/nostr

  • Zalo — @openclaw/zalo

  • Microsoft Teams — @openclaw/msteams

  • Google Antigravity OAuth (provider authentication) — bundled as google-antigravity-auth (disabled by default)

  • Gemini CLI OAuth (provider authentication) — bundled as google-gemini-cli-auth (disabled by default)

  • Qwen OAuth (provider authentication) — bundled as qwen-portal-auth (disabled by default)

  • Copilot Proxy (provider authentication) — a local VS Code Copilot Proxy bridge; different from the built-in github-copilot device login (bundled, disabled by default)

OpenClaw plugins are TypeScript modules loaded at runtime via jiti. Configuration validation does not execute plugin code; it uses the plugin manifest and JSON Schema. See Plugin Manifest. A plugin can register:

  • Gateway RPC methods

  • Gateway HTTP handlers

  • Agent tools

  • CLI commands

  • Background services

  • Optional configuration validation

  • Skills (by listing the skills directory in the plugin manifest)

  • Auto-reply commands (executed without invoking the AI agent)

Plugins run in the same process as the Gateway, so treat them as trusted code. Tool authoring guide: Plugin Agent Tools.

Runtime Helpers

Plugins can access selected core helper tools via api.runtime. For telephony TTS:

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

Notes:

  • Uses the core messages.tts configuration (OpenAI or ElevenLabs).

  • Returns a PCM audio buffer + sample rate. The plugin must resample/encode for the provider.

  • Edge TTS does not support telephony.

Discovery and Priority

OpenClaw scans in this order:

  1. Configuration paths

  • plugins.load.paths (files or directories)

  1. Workspace extensions

  • <workspace>/.openclaw/extensions/*.ts

  • <workspace>/.openclaw/extensions/*/index.ts

  1. Global extensions

  • ~/.openclaw/extensions/*.ts

  • ~/.openclaw/extensions/*/index.ts

  1. Bundled extensions (shipped with OpenClaw, disabled by default)

  • <openclaw>/extensions/*

Bundled plugins must be explicitly enabled via plugins.entries.<id>.enabled or openclaw plugins enable <id>. Installed plugins are enabled by default, but can be disabled in the same way. Each plugin must contain an openclaw.plugin.json file in its root directory. If a path points to a file, the plugin root directory is the directory of the file, and it must contain the manifest. If multiple plugins resolve to the same id, the first match in the order above wins, and lower-priority copies are ignored.

Package Collections

A plugin directory can contain a package.json with openclaw.extensions:

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

Each entry becomes a plugin. If the package lists multiple extensions, the plugin id becomes name/<fileBase>. If your plugin imports npm dependencies, install them in that directory so that node_modules is available (npm install / pnpm install).

Channel Catalog Metadata

Channel plugins can broadcast onboarding metadata via openclaw.channel and installation hints via openclaw.install. This keeps the core catalog data-free. Example:

xxxxxxxxxx
{
  "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 can also merge external channel catalogs (for example, MPM registry exports). Place the JSON file in one of the following locations:

  • ~/.openclaw/mpm/plugins.json

  • ~/.openclaw/mpm/catalog.json

  • ~/.openclaw/plugins/catalog.json

Or point OPENCLAW_PLUGIN_CATALOG_PATHS (or OPENCLAW_MPM_CATALOG_PATHS) to one or more JSON files (separated by commas/semicolons/PATH). Each file should contain { "entries": [ { "name": "@scope/pkg", "openclaw": { "channel": {...}, "install": {...} } } ] }.

Plugin ID

Default plugin id:

  • Package collection: the name of package.json

  • Standalone file: the file base name (~/.../voice-call.ts → voice-call)

If the plugin exports an id, OpenClaw uses it, but issues a warning when it does not match the configured id.

Configuration

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

Fields:

  • enabled: master switch (default: true)

  • allow: allowlist (optional)

  • deny: denylist (optional; deny takes precedence)

  • load.paths: additional plugin files/directories

  • entries.<id>: per-plugin switch + configuration

Configuration changes require restarting the Gateway. Validation rules (strict):

  • Unknown plugin ids in entries, allow, deny, or slots are an error.

  • Unknown channels.<id> keys are an error, unless the plugin manifest declares the channel id.

  • Plugin configuration is validated using the JSON Schema embedded in openclaw.plugin.json (configSchema).

  • If a plugin is disabled, its configuration is retained and a warning is issued.

Plugin Slots (Exclusive Categories)

Some plugin categories are exclusive (only one active at a time). Use plugins.slots to select which plugin owns the slot:

xxxxxxxxxx
{
  plugins: {
    slots: {
      memory: "memory-core", // or "none" to disable memory plugins
    },
  },
}

If multiple plugins declare kind: "memory", only the selected one is loaded. The others are disabled with diagnostic information.

Control Interface (Schema + Labels)

The control interface uses config.schema (JSON Schema + uiHints) to render better forms. At runtime, OpenClaw augments uiHints based on the discovered plugins:

  • Adds per-plugin labels for plugins.entries.<id> / .enabled / .config

  • Merges optional plugin-provided configuration field hints at: plugins.entries.<id>.config.<field>

If you want plugin configuration fields to display good labels/placeholders (and to mark keys as sensitive), provide uiHints and JSON Schema in the plugin manifest. Example:

xxxxxxxxxx
{
  "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

xxxxxxxxxx
openclaw plugins list
openclaw plugins info <id>
openclaw plugins install <path>                 # copy a local file/dir into ~/.openclaw/extensions/<id>
openclaw plugins install ./extensions/voice-call # relative path ok
openclaw plugins install ./plugin.tgz           # install from a local tarball
openclaw plugins install ./plugin.zip           # install from a local zip
openclaw plugins install -l ./extensions/voice-call # link (no copy) for dev
openclaw plugins install @openclaw/voice-call # install from npm
openclaw plugins update <id>
openclaw plugins update --all
openclaw plugins enable <id>
openclaw plugins disable <id>
openclaw plugins doctor

plugins update applies only to npm installations tracked under plugins.installs. Plugins can also register their own top-level commands (for example: openclaw voicecall).

Plugin API (Overview)

A plugin exports one of the following:

  • A function: (api) => { ... }

  • An object: { id, name, configSchema, register(api) { ... } }

Plugin Hooks

Plugins can ship hooks and register them at runtime. This lets a plugin bundle event-driven automation without installing a separate hook package.

Example

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

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

Notes:

  • Hook directories follow the normal hook structure (HOOK.md + handler.ts).

  • Hook eligibility rules still apply (OS/binary/environment/configuration requirements).

  • Hooks managed by a plugin appear as plugin:<id> in openclaw hooks list.

  • You cannot enable/disable plugin-managed hooks via openclaw hooks; instead, enable/disable the plugin.

Provider Plugins (Model Authentication)

Plugins can register model provider authentication flows so that users can run OAuth or API key setup inside OpenClaw (no external scripts required). Register a provider via api.registerProvider(...). Each provider exposes one or more authentication methods (OAuth, API key, device code, etc.). These methods drive:

  • openclaw models auth login --provider <id> [--method <id>]

Example:

xxxxxxxxxx
api.registerProvider({
  id: "acme",
  label: "AcmeAI",
  auth: [
    {
      id: "oauth",
      label: "OAuth",
      kind: "oauth",
      run: async (ctx) => {
        // Run OAuth flow and return auth profiles.
        return {
          profiles: [
            {
              profileId: "acme:default",
              credential: {
                type: "oauth",
                provider: "acme",
                access: "...",
                refresh: "...",
                expires: Date.now() + 3600 * 1000,
              },
            },
          ],
          defaultModel: "acme/opus-1",
        };
      },
    },
  ],
});

Notes:

  • run receives a ProviderAuthContext with the prompter, runtime, openUrl, and oauth.createVpsAwareHandlers helper tools.

  • Return a configPatch when a default model or provider configuration needs to be added.

  • Return defaultModel so that --set-default can update the agent defaults.

Registering Message Channels

Plugins can register channel plugins that behave like built-in channels (WhatsApp, Telegram, etc.). Channel configuration lives under channels.<id> and is validated by your channel plugin code.

xxxxxxxxxx
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 });
}

Notes:

  • Place the configuration under channels.<id> (not plugins.entries).

  • meta.label is used for the label in CLI/UI lists.

  • meta.aliases adds alternate ids used for normalization and CLI input.

  • meta.preferOver lists channel ids to skip auto-enabling when both are configured.

  • meta.detailLabel and meta.systemImage let the UI display richer channel labels/icons.

Writing a New Message Channel (Step-by-Step Guide)

Use this approach when you want a new chat interface ("message channel") rather than a model provider. Model provider documentation is located under /providers/*.

  1. Choose the id + configuration structure

  • All channel configuration lives under channels.<id>.

  • For multi-account setups, prefer channels.<id>.accounts.<accountId>.

  1. Define the channel metadata

  • meta.label, meta.selectionLabel, meta.docsPath, meta.blurb control the CLI/UI list.

  • meta.docsPath should point to a documentation page like /channels/<id>.

  • meta.preferOver lets the plugin replace another channel (auto-enabling prefers it).

  • meta.detailLabel and meta.systemImage are used by the UI for detailed text/icons.

  1. Implement the required adapters

  • config.listAccountIds + config.resolveAccount

  • capabilities (chat types, media, threading, etc.)

  • outbound.deliveryMode + outbound.sendText (for basic sending)

  1. Add optional adapters as needed

  • setup (wizard), security (direct message policy), status (health/diagnostics)

  • gateway (start/stop/login), mentions, threading, streaming

  • actions (message actions), commands (native command behavior)

  1. Register the channel in the plugin

  • api.registerChannel({ plugin })

Minimal configuration example:

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

Minimal channel plugin (outbound only):

xxxxxxxxxx
const plugin = {
  id: "acmechat",
  meta: {
    id: "acmechat",
    label: "AcmeChat",
    selectionLabel: "AcmeChat (API)",
    docsPath: "/channels/acmechat",
    blurb: "AcmeChat messaging channel.",
    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 ({ text }) => {
      // deliver `text` to your channel here
      return { ok: true };
    },
  },
};

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

Load the plugin (extension directory or plugins.load.paths), restart the Gateway, then configure channels.<id> in the configuration.

Agent Tools

See the dedicated guide: Plugin Agent Tools.

Registering Gateway RPC Methods

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

Registering CLI Commands

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

Registering Auto-Reply Commands

Plugins can register custom slash commands that execute without invoking the AI agent. This is useful for toggle commands, status checks, or quick actions that do not need LLM processing.

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

Command handler context:

  • senderId: the sender's ID (if available)

  • channel: the channel that sent the command

  • isAuthorizedSender: whether the sender is an authorized user

  • args: the arguments passed after the command (if acceptsArgs: true)

  • commandBody: the full command text

  • config: the current OpenClaw configuration

Command options:

  • name: the command name (without the leading /)

  • description: the help text displayed in the command list

  • acceptsArgs: whether the command accepts arguments (default: false). If false and arguments are provided, the command does not match and the message is passed to other handlers

  • requireAuth: whether an authorized sender is required (default: true)

  • handler: a function that returns { text: string } (can be asynchronous)

Example with authorization and arguments:

xxxxxxxxxx
api.registerCommand({
  name: "setmode",
  description: "Set plugin mode",
  acceptsArgs: true,
  requireAuth: true,
  handler: async (ctx) => {
    const mode = ctx.args?.trim() || "default";
    await saveMode(mode);
    return { text: `Mode set to: ${mode}` };
  },
});

Notes:

  • Plugin commands are processed before built-in commands and the AI agent

  • Commands are registered globally and apply to all channels

  • Command names are case-insensitive (/MyStatus matches /mystatus)

  • Command names must start with a letter and may contain only letters, digits, hyphens, and underscores

  • Reserved command names (such as help, status, reset, etc.) cannot be overridden by plugins

  • Duplicate command registration across plugins fails with a diagnostic error

Registering Background Services

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

Naming Conventions

  • Gateway methods: pluginId.action (for example: voicecall.status)

  • Tools: snake_case (for example: voice_call)

  • CLI commands: kebab or camel, but avoid conflicts with core commands

Skills

A plugin can ship Skills in the repository (skills/<name>/SKILL.md). Enable it with plugins.entries.<id>.enabled (or another configuration gate), and make sure it exists in your workspace/managed Skills location.

Distribution (npm)

Recommended packaging approach:

  • Main package: openclaw (this repository)

  • Plugins: independent npm packages under @openclaw/* (for example: @openclaw/voice-call)

Publishing contract:

  • The plugin package.json must contain openclaw.extensions with one or more entry files.

  • Entry files can be .js or .ts (jiti loads TS at runtime).

  • openclaw plugins install <npm-spec> uses npm pack, extracts to ~/.openclaw/extensions/<id>/, and enables it in the configuration.

  • Configuration key stability: scoped packages are normalized to an unscoped id for plugins.entries.*.

Example Plugin: Voice Call

This repository contains a voice call plugin (Twilio or a log fallback):

  • Source: extensions/voice-call

  • Skills: skills/voice-call

  • CLI: openclaw voicecall start|status

  • Tool: voice_call

  • RPC: voicecall.start, voicecall.status

  • Configuration (twilio): provider: "twilio" + twilio.accountSid/authToken/from (optional statusCallbackUrl, twimlUrl)

  • Configuration (dev): provider: "log" (no network)

See Voice Call and extensions/voice-call/README.md for setup and usage.

Security Considerations

Plugins run in the same process as the Gateway. Treat them as trusted code:

  • Install only plugins you trust.

  • Prefer the plugins.allow allowlist.

  • Restart the Gateway after changes.

Testing Plugins

Plugins can (and should) ship with tests:

  • In-repository plugins can keep Vitest tests under src/** (for example: src/plugins/voice-call.plugin.test.ts).

  • Separately published plugins should run their own CI (lint/build/test) and verify that openclaw.extensions points to the built entry point (dist/index.js).

 

For more about plugins, refer to: Plugins - OpenClaw

OpenClawGate Gateway User Manual
OpenClawHub Introduction (Skill Installation)

COMPANY

  • About us
  • Team Style
  • Blog

LEARNING & EXPLORATION

  • Tutorials
  • Edge AI hardware
  • Educational robots
  • Embedded intelligent hardware

WHERE TO BUY

  • Yahboom Online Store
  • Amazon
  • Alibaba
  • AliExpress
  • Mercado

TECHNOLOGY SUPPORT

  • Email: support@yahboom.com

BE A DISTRIBUTOR

  • Email: sales@yahboom.com
QR Code

Copyright © 2017-2026 Yahboom. All Rights Reserved.

EN/中文