Preface

DeepSeek Harness (hereinafter referred to as DSH) treats models, tools, sessions, sandboxes, and interfaces as replaceable plugins. The official repository deepseek-ai/deepseek-harness uses the slogan “Everything is a Plugin”: capabilities are not hardcoded into the core, but instead assembled by Cordis at startup based on a profile. A large number of extensions have thus emerged in the community, covering vision, memory, notifications, themes, and other areas.

Most plugins remain within the software ecosystem. Once you need to hand physical devices over Bluetooth, serial, or USB to an agent for control, things immediately become complex: you have to select protocols, launch local services, handle permissions, and prevent the model from generating unrestricted commands for intensity and duration. General-purpose control stacks like Buttplug / Intiface can cover a wide range of hardware, but they do not automatically complete the entire workflow of “asking for model, selecting backend, setting limits” by default.

dsh-toy is a DSH plugin built specifically for this workflow. It bundles connection, discovery, and control into a set of model-visible tools, while confining intensity, duration, and stop behavior to configuration. This article is organized after cross-checking the community directory and GitHub repository, to help existing DSH users decide whether to install it, how to install it, and what it can do.

What It Is

dsh-toy is a DeepSeek Harness plugin for connecting adult toys to DSH. The English description of the repository is Toy Control Protocol for DSH, and the detail is more specific in package.json: it targets Buttplug / Intiface and MonsterParty control with security boundaries. The maintainer is GitHub user c3ll256, the primary language is TypeScript, and the license is BSD-3-Clause. The community directory deepseek-harness-plugin.com categorizes it under “Tools & Capabilities”, with an inclusion date of 2026-08-15; the repository was created on 2026-08-14, and as of writing, the GitHub page shows approximately 53 stars (the directory page marked 37 stars at the same time, please refer to the repository page for accuracy). The current package.json version is 0.2.0, requiring Node.js 22.19 or higher.

First, it is necessary to clarify its ecological position. DSH itself is an open-source agent runtime developed by DeepSeek, and it is still in developer preview. The official entry point for discovering community plugins is the GitHub topic dsh-plugin, and there is no official app store. deepseek-harness-plugin.com is an independent community directory, not affiliated with DeepSeek or Fanfou; the installation commands provided on the directory page are for easy copying, but do not mean they have been audited officially.

The problem this plugin solves is also very specific: users do not need to understand underlying protocols, nor do they need to manually launch Intiface. When connecting, the agent will first ask for the brand and model, then automatically select the connection method; if the user truly does not know, it will enter unknown hardware discovery. Brand and model names are not on a whitelist, and the agent will pass the text reported by the user as-is.

Core Features

Based on the repository README and source code, the capabilities can be divided into the following sections.

1. Automatic Connection Method Selection

Before calling toy_connect, the agent must first ask for the model, and pass the model (and brand if known) to the tool. The tool will not let users choose the underlying protocol. There are currently three paths:

  • On macOS, for unknown hardware, a read-only raw CoreBluetooth broadcast discovery will be performed first: no Intiface will be launched, no devices will be connected, and no characteristic values will be written. The scanned broadcast name can be used as hardware evidence for subsequent toy_connect; the raw BLE ID cannot be used as a controllable device ID.
  • Models using regular Bluetooth, serial, or USB use Buttplug / Intiface. The plugin will first try existing local services; if 127.0.0.1:12345 refuses the connection, it will automatically launch the Intiface Engine.
  • Known shared link models from brands like Anki, MiJi, and Zuiqingfeng use MonsterParty. Known dual-channel devices will expose each output channel separately.

Unknown or undocumented names still follow the same path: pass the text reported by the user to toy_connect, then call toy_scan. The README clearly requires: the agent must not guess protocols, nor write data to arbitrary BLE characteristics. Scans only return devices covered by the compatibility mappings defined by the Intiface upstream or verified via physical devices; an empty result means the device is still unsupported or currently unavailable, and does not permit destructive probing.

2. Automatic Intiface Engine Launch

For the local device path, the plugin will first look for intiface-engine in the PATH. If it is not installed, it will default to downloading a fixed version from the official Buttplug GitHub Release, verify the SHA-256 hash, cache it to the user directory, then launch it. Currently, automatic download supports macOS ARM64, Linux x64/ARM64, and Windows x64; for other platforms, you need to point intifaceExecutable to the installed engine. You can disable downloading with intifaceAutoDownload: false.

When launching manually, the actual command is:

intiface-engine --websocket-port 12345 --use-bluetooth-le --use-serial --use-hid

The plugin will only terminate processes started by itself when disconnecting or uninstalling, and will not shut down Intiface instances that the user was already running. When manually launched, the plugin will also write verified compatibility mappings to a temporary user-device configuration with restricted permissions, and delete them when shutting down; external running Intiface instances will continue to use their own configurations, and if you want to use the plugin’s built-in mappings, you need to first stop that external service.

3. Bounded Control and Stopping

Control exposed to the model is not “arbitrary characteristic value writes”, but scalar commands with limits. The security restrictions listed in the README include:
- Shared tokens are only stored in the plugin configuration, and will not appear in model-visible tool parameters or results.
- Raw BLE discovery is a read-only scan.
- Automatic stop after 30 seconds by default.
- Zero-duration hold is forbidden by default, and can only be enabled by explicitly configuring allowHold: true.
- maxIntensityPercent and maxDurationSeconds will be enforced before sending commands to the backend.
- New commands for the same device will replace the old automatic stop timer.
- Omitting the device ID in toy_stop will stop all devices.
- Plugin uninstallation, HMR, or toy_disconnect will stop output and wait for the WebSocket to close.

In the source code, the scalar types currently exposed by toy_control are vibrate, oscillate, constrict, inflate, and suction. Buttplug connections currently only expose scalar features that can be mapped to percentages; position, orientation, sensors, raw access, and subscriptions are not within the current scope.

4. Physically Verified Compatibility Mappings

The plugin has a built-in compatibility mapping for devices with BLE name RoomFun, model identifier RF_CANNON_PT3, and firmware 4.3, exposed as RoomFun Cannon with one vibration channel. The README clearly states: other RoomFun models are not assumed to be compatible.

The implementation references the protocol records from Chemtrails, as well as the device abstraction and message formats from Buttplug and Buttplug Protocol Specification. The repository NOTICE explains that this is an independent TypeScript implementation, and does not redistribute the source code of the above projects; protocol names and message fields are only used for interoperability.

Installation and Activation

The installation command given on the community directory page is:

dsh plugin add github:c3ll256/dsh-toy

The directory page also reminds: for reproducible installations, you can pin the commit hash:

dsh plugin add github:c3ll256/dsh-toy#commit

Replace #commit with the actual commit hash. Do not manually piece together the owner/repo by name, please follow the command from the directory page as-is.

The command given in the repository README uses a profile, and the runtime requirements are Node.js 22.19 or higher, and pnpm in the PATH. macOS raw BLE discovery also requires the Swift compiler provided by Xcode Command Line Tools. If you have not installed pnpm, the README recommends first running npm install --global pnpm@10, then:

npx -y @deepseek-ai/dsh plugin --profile web add github:c3ll256/dsh-toy

Launch DSH using the same profile:

npx -y @deepseek-ai/dsh web

The first command will permanently install and enable the bundle to the web profile, and you will not need to reinstall it when launching DSH in the future. To view the combined configuration or remove the plugin:

npx -y @deepseek-ai/dsh --profile web --dump-config
npx -y @deepseek-ai/dsh plugin --profile web remove dsh-toy

If you need other profiles, replace web with the corresponding profile name.

The default bundle configuration (consistent between the README and cordis.patch.yml) is as follows:

- id: dsh-toy
  config:
    buttplugProtocolVersion: 4
    intifaceExecutable: intiface-engine
    intifaceAutoDownload: true
    rawBleScanDurationMs: 10000
    defaultDurationSeconds: 30
    maxDurationSeconds: 300
    maxIntensityPercent: 100
    allowHold: false

buttplugUrl: ws://127.0.0.1:12345 is also defaulted in cordis.patch.yml. For older Intiface servers, you can set buttplugProtocolVersion to 3.

Typical Usage

Known Model

You can directly tell the agent:

My toy is Lovense Lush 3, please connect and scan.

The tool sequence for known models is: toy_connect → toy_scan → toy_list → toy_control → toy_stop → toy_disconnect.

Please turn on the device, keep it within close range, and prevent your phone app or other programs from occupying the connection before scanning. On macOS, the first scan may request Bluetooth permissions, and you need to allow the terminal or application running DSH to access Bluetooth.

Unknown Brand or Model

You can also say:

I don't know the brand and model, please use Bluetooth search directly.

On macOS, the agent will first call toy_scan_raw_ble. If a reasonable broadcast name is scanned, it will use this hardware-reported name for toy_connect; otherwise, it will fall back to unknown, automatically connect to Intiface and scan verified protocols. When raw discovery is unavailable or yields no results, continue calling toy_connect(model: "unknown").

The tools exposed to the model are as follows:
| Tool | Function |
|—|—|
| toy_scan_raw_ble | Bypass Intiface on macOS to perform read-only discovery of connectable raw BLE broadcasts |
| toy_connect | Automatically connect based on the model provided by the user; use unknown when you don’t know |
| toy_scan | Discover available devices |
| toy_list | List device IDs and controllable features |
| toy_control | Send bounded scalar commands |
| toy_stop | Stop one or all devices |
| toy_disconnect | Stop output and close the connection |

After reconnecting, you should call toy_list again to refresh the device IDs, do not reuse old IDs.

Supported shared link tokens should be placed in environment variables, not in conversations or Git repositories:

MONSTERPARTY_TOKEN=<TOKEN>

Then override the plugin configuration in your profile’s cordis.patch.yml:

- id: dsh-toy
  config:
    monsterPartySessionToken: !!js process.env.MONSTERPARTY_TOKEN
    defaultDurationSeconds: 30
    maxDurationSeconds: 300
    maxIntensityPercent: 100
    allowHold: false

The README notes: shared tokens usually can only be used once and expire after disconnection; you should generate a new link before reconnecting. Tokens are temporary control credentials, do not commit them to Git, and do not expose them in logs or conversations.

Common Troubleshooting

The troubleshooting items listed in the README can be directly referenced:
- spawn intiface-engine ENOENT appears: Update to a version that includes automatic downloading, confirm intifaceAutoDownload: true, and ensure you can access GitHub.
- Scan results are empty: Turn on system Bluetooth, confirm the device has power and is nearby, and disconnect the phone app or other control programs.
- Intiface launches but scanning fails: Check if the system has granted Bluetooth permissions to DSH or the terminal.
- Raw BLE scan fails to build auxiliary programs: Run xcode-select --install, or fall back to using Intiface.
- MonsterParty connection is rejected: The token may have been used or expired, try generating a new link.

Applicable Scenarios and Notes

It is suitable for users who are already running DSH and want to drive local or shared link devices using natural language. It wraps protocol selection, Intiface launching, and intensity/duration limits into the plugin, and the model only sees a limited set of tools. It is not suitable for treating any unknown Bluetooth device as a general-purpose peripheral for probing: an empty scan result does not permit writing to characteristics further.

There are several boundaries to clarify before use.

First, the plugin runs with the permissions of the current DSH process, and may execute code during installation. Both the directory page and the repository require: check the source code repository and license before installing. The community directory is not an official app store, and does not replace your own security review. For reproducible environments, pin the commit hash.

Second, only control devices that you own or have obtained explicit authorization for. This is a stated prerequisite for use in the README, not an optional item.

Third, the scope of capabilities is narrower than “all toy protocols”. MonsterParty connections only implement the relay behavior recorded in Chemtrails and the AKN_DS_SUCKEGG mapping, and changes to manufacturer protocols may require updating the implementation. Raw BLE broadcast discovery only supports macOS, relies on the Swift compiler from Xcode Command Line Tools, and only performs read-only discovery, not a general-purpose control protocol for unknown devices. Tests use local protocol fixtures and do not connect to physical hardware.

Fourth, automatically downloading Intiface requires access to GitHub; you need to prepare the engine yourself for other CPU/OS combinations. The first scan on macOS will also require handling system Bluetooth authorization.

Summary

The way dsh-toy connects adult toys to DSH is not to ask users to first understand Buttplug and then write WebSocket code manually, but rather: ask for the model, automatically select the backend, confine control to percentages and seconds, and stop output when uninstalling or disconnecting. It is a community open-source plugin maintained by c3ll256, licensed under BSD-3-Clause, and has no affiliation with DeepSeek’s official core repository.

Directory page: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-toy/

GitHub: https://github.com/c3ll256/dsh-toy