ClawVoice

Connects to a live voice session, receiving and sending messages in real time via a WebSocket interface using the bundled client script.

Security Scan

The skill is a straightforward voice-WebSocket bridge that forwards user speech to a local OpenClaw agent; its code and instructions are consistent with that purpose.

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.

Assessment

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.

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 '<message>', 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": "<stdout>"}

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.