← Back to Skills Marketplace
niczy

ClawVoice

by niczy · GitHub ↗ · v0.0.2
cross-platform ✓ Security Clean
2082
Downloads
1
Stars
1
Active Installs
2
Versions
Install in OpenClaw
/install claw-voice
Description
Connects to a live voice session, receiving and sending messages in real time via a WebSocket interface using the bundled client script.
README (SKILL.md)

Claw Voice

You are connected to a live user session via voice. The user is speaking to you through a voice interface. Use the bundled client.py script to communicate with them in real time.

The script is located at $skill_dir/client.py.

Sending a message to the user

To say something to the user, run:

uv run python $skill_dir/client.py send "Hello! How can I help you today?"

The server echoes back a confirmation as JSON:

{"type": "echo", "content": "Hello! How can I help you today?"}

Receiving the next message from the user

To wait for the user to say something:

uv run python $skill_dir/client.py recv

This blocks until the user speaks, then prints their message as JSON and exits:

{"type": "message", "content": "What's the weather like?"}

Use --timeout to control how long to wait (default 30s):

uv run python $skill_dir/client.py recv --timeout 60

If the timeout expires with no message, it prints an error and exits with code 1.

Listening for multiple messages

To receive a stream of messages over a period of time:

uv run python $skill_dir/client.py listen --timeout 60

This prints each incoming message as a JSON line until the timeout expires:

{"type": "message", "content": "Tell me a joke"}
{"type": "message", "content": "Actually, make it about cats"}

Running as an agent bridge

The agent command creates a loop: it listens for user messages, forwards each one to openclaw agent --agent main --message '\x3Cmessage>', captures the stdout, and sends it back to the user over the WebSocket.

uv run python $skill_dir/client.py agent

This runs indefinitely by default. Use --timeout to limit the session:

uv run python $skill_dir/client.py agent --timeout 300

The flow for each message:

  1. User speaks -> server sends {"type": "message", "content": "..."} to the client
  2. Client runs openclaw agent --agent main --message '...' and captures stdout
  3. Client sends the agent's response back: {"type": "message", "content": "\x3Cstdout>"}

Logs are printed to stderr-style output as [user] and [agent] prefixed lines.

Connection options

All commands accept --url to override the default WebSocket address:

uv run python $skill_dir/client.py --url ws://$host:$port/connect send "Hi"

Default URL: ws://localhost:3111/connect

Message types reference

Messages you send (agent -> user)

Type Fields Description
message content (string) Text to speak/display to the user

Messages you receive (user -> agent)

Type Fields Description
message content (string) What the user said (transcribed text)
echo content (string) Server confirmation of your sent message — ignore these
pong Connection health check response — ignore these

Behavior guidelines

  • Respond promptly to every message you receive from the user.
  • Keep responses conversational and concise — the user is speaking, not reading.
  • Send one message at a time. Do not batch multiple sends.
  • Ignore echo messages — they are confirmations, not user input.
  • Use recv for turn-based conversation. Use listen when you expect the user to say multiple things.
Usage Guidance
This skill is a simple WebSocket-to-agent bridge: it connects to a WebSocket (default ws://localhost:3111/connect), sends/receives JSON messages, and can forward each user message to your local `openclaw agent` CLI and return its stdout. Before installing or running it, consider: (1) it will forward user transcripts to the local agent — ensure you trust what the agent does and logs; (2) it spawns a shell command to run `openclaw agent` (the message is safely quoted with shlex.quote, reducing shell-injection risk, but you should still be cautious about running arbitrary user-supplied content in your environment); (3) the `--url` option can point to a remote WebSocket if changed — only use trusted endpoints. If you want extra safety, run this skill in a restricted/sandboxed environment or inspect/limit what the local `openclaw agent` is allowed to do.
Capability Analysis
Type: OpenClaw Skill Name: claw-voice Version: 0.0.2 The skill bundle is benign. The `client.py` script acts as a bridge between a WebSocket voice interface and the `openclaw agent` command. Crucially, it uses `shlex.quote()` to properly sanitize user input before passing it to the `openclaw agent` command, preventing shell injection. The `skill.md` documentation accurately describes this functionality and does not contain any prompt injection attempts or instructions for malicious behavior. There is no evidence of data exfiltration, persistence mechanisms, or other malicious activities.
Capability Assessment
Purpose & Capability
The SKILL.md and client.py both implement a WebSocket client that sends/receives voice-transcribed messages and (optionally) forwards them to the local `openclaw agent`. Required resources (none) match the described functionality; nothing requested is unrelated to a voice-agent bridge.
Instruction Scope
The runtime instructions are narrowly scoped to connecting to a WebSocket, sending/receiving JSON messages, and optionally running `openclaw agent` for each user message. This will forward user text to the local agent and return its stdout to the user — expected for a voice bridge. Minor caution: the skill executes a local CLI (`openclaw agent`) with user content quoted and returned; that means whatever the local agent can do (and any logs it writes) may be involved in these sessions.
Install Mechanism
Instruction-only skill with no install spec and only a small Python client; nothing is downloaded or written to disk beyond running the provided script.
Credentials
The skill declares no environment variables, credentials, or config paths. The code uses a default localhost WebSocket and allows an override via `--url`. No unexpected secrets are requested.
Persistence & Privilege
The skill does not request permanent presence (always:false) and does not modify other skills or system configuration. It runs as an invoked process and forwards messages as documented.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install claw-voice
  3. After installation, invoke the skill by name or use /claw-voice
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v0.0.2
- Added a new CLI Python client script (`client.py`) for real-time voice interaction over WebSocket. - The CLI supports sending messages, receiving messages, streaming/listening for multiple messages, and agent bridging. - Updated documentation to detail usage of the client script, including new command options and workflows. - Improved connection configuration options with a default and customizable WebSocket URL. - Clarified message type reference and behavior guidelines in the documentation.
v0.0.1
Initial release of Claw Voice skill. - Enables real-time conversations via WebSocket and voice interface. - Defines JSON-based messaging protocol for agent-user interaction. - Supports sending and receiving text messages, connection pings, and status echoes. - Provides clear behavior guidelines for conversational and responsive interaction.
Metadata
Slug claw-voice
Version 0.0.2
License
All-time Installs 1
Active Installs 1
Total Versions 2
Frequently Asked Questions

What is ClawVoice?

Connects to a live voice session, receiving and sending messages in real time via a WebSocket interface using the bundled client script. It is an AI Agent Skill for Claude Code / OpenClaw, with 2082 downloads so far.

How do I install ClawVoice?

Run "/install claw-voice" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is ClawVoice free?

Yes, ClawVoice is completely free (open-source). You can download, install and use it at no cost.

Which platforms does ClawVoice support?

ClawVoice is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created ClawVoice?

It is built and maintained by niczy (@niczy); the current version is v0.0.2.

💬 Comments