How to Install and Use Feishu Evolver Wrapper in OpenClaw

Open your terminal and run the clawhub install command below. The feishu-evolver-wrapper skill includes everything in feishu-bridge plus the Evolver middleware components — you do not need to install both skills separately. If you already have feishu-bridge installed, feishu-evolver-wrapper replaces it with a superset of functionality. ClawHub downloads the skill package, verifies its signature, and registers it with your OpenClaw configuration. The installation takes 15-40 seconds. On completion, you will see a success message listing the installed version and the required configuration keys: FEISHU_APP_ID, FEISHU_APP_SECRET, and FEISHU_EVOLVER_VERIFICATION_TOKEN (for event subscription verification). If you already have feishu-bridge installed, you can safely install feishu-evolver-wrapper alongside it — they are independent skills. However, for simplicity, most users choose to use one or the other rather than both simultaneously.

1# Install feishu-evolver-wrapper
2clawhub install feishu-evolver-wrapper
3
4# Verify installation
5clawhub list | grep feishu
6
7# See all available config options
8clawhub info feishu-evolver-wrapper

Navigate to open.feishu.cn and log in. If you already created a Feishu app for feishu-bridge, you can extend that app with event subscription permissions. If starting fresh, click 'Create App' and follow the prompts to create a new In-House app. In your app settings, navigate to 'Permissions & Scopes'. For the Evolver wrapper, you need a broader set of permissions than basic messaging: add `im:message` (read and send messages), `im:message.receive_v1` (receive message events), `im:chat` (manage chat membership), and `im:chat.member` (react to member join/leave events). Save your permission changes. Next, go to 'Event Subscriptions' in your app settings. This is where you register the event types that Feishu will send to OpenClaw. Enable the event types relevant to your automation: `im.message.receive_v1` for incoming messages is the most common starting point. Feishu will ask for a 'Request URL' — this is the webhook endpoint where OpenClaw's Evolver middleware listens for events. For local OpenClaw instances, you will need a tunneling tool like ngrok to expose a public URL; for server-deployed OpenClaw, use your server's public URL. Feishu's event subscription setup also generates an Encrypt Key and Verification Token — copy both, as you will need the Verification Token for OpenClaw configuration.

With your Feishu app credentials and Evolver Verification Token ready, configure all required values in OpenClaw. The feishu-evolver-wrapper needs three core variables: your Feishu App ID, your App Secret, and the Evolver Verification Token from the Event Subscriptions page. Set all three using the `clawhub config set` command or by adding them to your `~/.openclaw/.env` file. The environment variable names must match exactly — incorrect names will cause silent failures where the skill installs but events do not trigger. After setting all three values, run `clawhub reload` to apply the configuration. OpenClaw will start the Evolver middleware webhook listener on its configured port, which Feishu can now send events to. You can verify the webhook is running by checking OpenClaw's status output.

1# Add to ~/.openclaw/.env
2FEISHU_APP_ID=cli_your_app_id_here
3FEISHU_APP_SECRET=your_app_secret_here
4FEISHU_EVOLVER_VERIFICATION_TOKEN=your_verification_token_here
5
6# Or set via clawhub config
7clawhub config set FEISHU_APP_ID cli_your_app_id
8clawhub config set FEISHU_APP_SECRET your_secret
9clawhub config set FEISHU_EVOLVER_VERIFICATION_TOKEN your_token
10
11# Apply and verify
12clawhub reload
13clawhub status feishu-evolver-wrapper

With the Evolver middleware running, you can now define event-triggered workflows directly from OpenClaw chat. The feishu-evolver-wrapper skill accepts workflow definitions in natural language and translates them into event subscription rules within the Evolver layer. Start with a simple test: define a rule that responds to a specific message in a Feishu chat you have access to. Once the rule is defined, send the triggering message from your Feishu account and verify that OpenClaw responds through the Evolver middleware. Evolver workflows support conditions, multi-step sequences, and state persistence within a conversation session. A 'conversation session' in Evolver terms is a series of message exchanges between one Feishu user and the OpenClaw bot within a time window — Evolver tracks context across these exchanges so your bot can ask follow-up questions, validate responses, and build up complex inputs before taking an action. RapidDev can help configure complex Evolver workflow rules for enterprise teams building sophisticated Feishu automation — particularly useful for teams with conditional routing logic, integration with multiple back-end systems, and compliance requirements around message handling.

1# Advanced Evolver skill configuration in ~/.openclaw/skills/feishu-evolver-wrapper.yaml
2feishu-evolver-wrapper:
3  webhook_port: 3100               # port for Feishu event webhook listener
4  session_timeout_minutes: 10      # conversation session window for stateful workflows
5  max_workflow_steps: 10           # max steps in a single triggered workflow
6  default_response_format: "markdown"  # plain | markdown | card
7  event_types:                     # event types to subscribe to
8    - im.message.receive_v1
9    - im.chat.member.user.added_v3

Now that basic event triggering works, extend your automation to include multi-step logic with conditions. Evolver workflows can branch based on message content, user attributes, or time conditions — giving you the ability to build intelligent routing and response systems inside Feishu. A common pattern is a triage bot: a team member mentions a keyword in a channel, the Evolver trigger fires, OpenClaw evaluates the message content to determine priority, and routes to a different response or escalation path based on the evaluation. This replaces manual triage work with an automated first pass that humans then review. Define your conditional workflow in OpenClaw chat using natural language. Be explicit about the branching conditions — the more specific your description of the decision logic, the more accurately Evolver translates it into workflow rules. After defining the workflow, test each branch by sending messages that should trigger each path.