Preface

DeepSeek Harness (dsh) treats models, tools, sessions, and interfaces as plugins, with the official repository’s slogan being “Everything is a plugin”. In actual work, many people do not rely solely on dsh: BitFun is another desktop Agent that can write code, create documents, operate browsers and desktops. The two can run independently, but they are not interoperable by default — there is no ready-made channel to hand over a task from a dsh session to BitFun.

The Agent Client Protocol (ACP) is designed for this kind of docking: in local scenarios, clients and Agents communicate via JSON-RPC over stdio, with an approach similar to the old LSP. The official dsh has already provided the out-of-process ACP subagent package @deepseek-ai/dsh-subagent-acp; BitFun CLI has a built-in bitfun acp server. What was missing was a bundle to connect the two.

dsh-acp-for-bitfun does exactly this. This article is organized after checking against the community plugin directory, the plugin’s GitHub repository README / package.json / index.js, and the official repositories of DeepSeek Harness and BitFun: what it is, how to install it, how to verify it, and what its limitations are. The community plugin directory (deepseek-harness-plugin.com) is an independent site and has no official affiliation with DeepSeek / Hexun. Do not treat it as an official app store.

What It Is

dsh-acp-for-bitfun is a development and runtime plugin maintained by bobleer, hosted at GitHub bobleer/dsh-acp-for-bitfun, licensed under MIT, with the current version 0.1.0, primarily written in JavaScript. Both the directory page and GitHub show 9 stars.

It solves a very specific problem: connecting BitFun to dsh via ACP v1 over stdio as a subagent for the current session. Once installed, any dsh session can call the model-visible tool subagent_bitfun to delegate tasks to BitFun for execution.

The plugin itself is a dsh bundle: the Cordis patch file cordis.patch.yml inserts a plugin line with the id bitfun-acp, and the entry point is index.js. It does not implement an ACP client from scratch, but reuses two official dsh packages:
- @deepseek-ai/dsh-subagent-acp: Acts as an ACP client, spawning child processes for each task
- @deepseek-ai/dsh-tool-subagent: Mounts the provider as a callable tool for models

The dependency versions are aligned with dsh, currently ^0.1.0-rc.6.

How It Works

The data flow from the README can be written as follows:

dsh session ──subagent_bitfun tool──▶ dsh-subagent-acp (ACP client)
                                        │  Each task spawns an independent process
                                        ▼
                              bitfun acp (ACP server, stdio JSON-RPC)
                                        │
                                        ▼
                              BitFun Agent Runtime

A typical delegation goes through: initialize → session/new → session/prompt, and streams agent_message_chunk responses. When the task ends, the child process’s stdin is closed, a 6-second grace period for EOF is given, followed by SIGTERM, and then SIGKILL if needed. The README specifies: BitFun child processes exit immediately on SIGTERM, and session data is persisted by BitFun itself.

The official dsh-subagent-acp implementation has added several boundary cases to avoid misunderstandings:
- Each child process has its own process, session, model, and tools, and does not inherit the parent session’s Cordis context.
- The parent side only passes the working directory (cwd) to the child; the child process cannot be constrained by the parent’s outputSchema / maxDepth / toolFilter.
- Permission requests will not prompt a user, but are automatically answered according to the configuration. The default for this plugin is reject.

When the plugin loads (checkOnStart defaults to true), it will first run bitfun --version. If the CLI is not in the PATH or the detection fails, the profile startup will fail directly, rather than waiting until the first delegation to throw an error.

Core Features

Expose BitFun as a subagent tool

For models, the default tool name is subagent_bitfun, and the provider name defaults to bitfun. When you ask the model to call this tool in a dsh session, the task will be sent to BitFun’s Agent Runtime. The tool is mounted via @deepseek-ai/dsh-tool-subagent, with maxDepth set to provider-managed (recursion budget is managed by the out-of-process BitFun child process itself), and one-shot background running is enabled.

Cold-start ACP child processes per task

Each delegation will spawn a new bitfun acp process, rather than reusing a persistent connection. The repository’s TODO.md still lists “connection reuse” as an unimplemented item: BitFun’s ACP server supports multiple sessions, but the current bundle chooses to cold-start per task. This provides better isolation at the cost of startup overhead.

Pre-launch CLI detection

index.js uses spawnSync(command, ['--version']) for detection. The error message on failure will prompt: install BitFun from https://github.com/GCWing/BitFun, run bitfun acp doctor for self-check, or configure command as the absolute path to the executable.

Overridable runtime parameters

The plugin id is bitfun-acp. You can override the command path, tool name, permission policy, and environment variables by id in your profile’s cordis.patch.yml without modifying the source code.

Installation and Enablement

Prerequisites

The repository README lists three items that must be met first:
1. BitFun CLI: The ACP server is built into the CLI, just installing the desktop client is not enough. After installation, confirm that bitfun acp doctor passes. The compatibility requirement is BitFun >= 0.2.17 (which provides the ACP v1 bitfun acp command). As of 2026-08-14, BitFun has released version 0.2.18.
2. dsh: Run npx @deepseek-ai/dsh --version, requires >= 0.1.0-rc.6, matching the version of the dependent subagent package. DeepSeek Harness is currently in developer preview, and the official README notes that there will be breaking changes.
3. pnpm: dsh plugin installation uses pnpm to install bundles.

The release notes for BitFun 0.2.18 also mention that the desktop client “natively supports DeepSeek Harness”, which refers to BitFun acting as an IDE connecting to dsh via ACP. This plugin works in the opposite direction: using BitFun as a subagent within dsh. The two can coexist, do not confuse them as the same feature.

Installation command from the community directory page

The installation command on the community directory page is as per the original text on the page, run it in the DeepSeek Harness terminal:

dsh plugin add github:bobleer/dsh-acp-for-bitfun

For a reproducible installation, fix the commit hash as per the directory page instructions:

dsh plugin add github:bobleer/dsh-acp-for-bitfun#commit

Replace the final commit with the actual commit hash from the repository. The plugin runs with the permissions of the current dsh process, and may execute code during installation. You should inspect the source code repository and license before installing.

Local installation method from the README

The plugin README also includes an installation method with --profile web, and installation from a local checkout:

# Add the bundle to the web profile (from npm or local directory)
dsh plugin --profile web add dsh-acp-for-bitfun

# Install from a local checkout
dsh plugin --profile web add ./dsh-acp-for-bitfun

# Start dsh
dsh web

It should be noted that the “publish to npm registry” item in the repository’s TODO.md is still unchecked. Before the npm package is officially published, the more reliable options are the GitHub source command from the directory page github:bobleer/dsh-acp-for-bitfun, or the local path installation method from the README. Do not assume that dsh plugin add dsh-acp-for-bitfun (without a GitHub source) can resolve from npm already.

Configuration

The default configuration does not need to be changed. When BitFun is not in the PATH, or you need to modify the tool name or permission policy, override the configuration by id in your profile’s cordis.patch.yml (path format: $DSH_HOME/profiles/<profile>/cordis.patch.yml). The example given in the README:

- id: bitfun-acp
  name: dsh-acp-for-bitfun
  config:
    command: /absolute/path/to/bitfun   # Defaults to 'bitfun' (resolved via PATH)
    providerName: bitfun                # Defaults to 'bitfun'
    toolName: subagent_bitfun           # Defaults to 'subagent_bitfun'
    permission: reject                  # 'reject' | 'allow'
    acpArgs: ['acp']                    # Defaults to ['acp']
    env: {}                             # Extra environment variables passed to the BitFun child process
    checkOnStart: true                  # Detect bitfun on load, fail startup if missing

The configuration items match the Schema in index.js:
- command: BitFun CLI executable, either a name on the PATH or an absolute path, defaults to bitfun.
- providerName: The provider name registered to ctx.subagents, defaults to bitfun.
- toolName: The tool name visible to models, defaults to subagent_bitfun.
- permission: Automatic response when BitFun initiates session/request_permission, either reject (default) or allow. The official ACP client will not present these prompts to the user.
- acpArgs: Arguments following command, defaults to ['acp'], which means actually starting bitfun acp.
- env: Extra environment variables passed to the BitFun child process. The official dsh-subagent-acp will overlay these key-value pairs on top of the parent process’s environment with credentials cleaned.
- checkOnStart: Whether to detect command --version when loading, defaults to true.

The built-in cordis.patch.yml of the bundle only inserts this plugin line without custom config; overrides take effect in your profile’s patch file.

Typical Usage: How to Verify After Installation

You can directly follow the verification steps given in the README.
1. Perform a self-check on the BitFun side:

   bitfun acp doctor
  1. Confirm that the plugin line exists in the dsh configuration tree:
   dsh --profile web --dump-config | grep -A 2 bitfun
  1. After starting a session, ask the model to call subagent_bitfun with a simple task. The example used in the README is:
   Reply hello using subagent_bitfun

If you can get the output from BitFun, it means that the ACP handshake, session/prompt and streaming collection functions are working. Whether more complex coding or desktop operations succeed depends on the local BitFun’s model configuration, workspace and permission policies, which is beyond the scope of this bundle.

Applicable Scenarios and Notes

This is suitable for users who are already using dsh and have installed BitFun CLI: they want to stay in DeepSeek Harness for their main session, and only delegate specific tasks (such as code modifications, documents or desktop operations handed over to BitFun) to it. It is also suitable for people evaluating ACP interoperability who need a ready-made dsh ↔ BitFun sample instead of writing a client from scratch.

It is recommended to review the following points before use:
1. Permissions and Process Isolation. The plugin runs with the permissions of the current dsh process, and may execute code during installation. Inspect the GitHub source code and MIT license before installing. The delegated BitFun child process is an independent process that does not share dsh’s Cordis context, but will use the parent session’s working directory; what it can do in this directory is determined by BitFun’s own capabilities and the permission policy. The default reject setting is more conservative; changing it to allow means automatically approving BitFun’s permission requests.
2. Version Locking. Requires BitFun >= 0.2.17 and dsh >= 0.1.0-rc.6. dsh is still in developer preview, and the plugin depends on its rc package. The README requires: sync this bundle upgrade when upgrading dsh. The repository’s TODO also notes that dependencies should be upgraded to follow the rc release cadence.
3. Per-Task Cold Start. The current implementation does not reuse the same bitfun acp process for multiple tasks. Short tasks will feel the overhead of one more process startup; this is a design trade-off, not an installation failure.
4. npm Package Is Not Yet a Default Installation Source. The directory page uses the GitHub source; the npm package name installation method in the README should not be considered available until the author checks “publish to npm” in their TODO list.
5. Repository Still Marks Unfinished Items. In addition to npm publishing and connection reuse, the TODO list also includes “add automated smoke testing”. Currently, verification mainly relies on bitfun acp doctor, dump-config, and actually calling the tool once in a session.

Summary

dsh-acp-for-bitfun does not create a new Agent Runtime or modify the dsh core. It connects the official ACP client and BitFun’s built-in ACP server together, adding a delegation entrance named subagent_bitfun to dsh sessions. The protocol is ACP v1, transmission is over stdio, and processes are isolated per task.

Community Directory: https://deepseek-harness-plugin.com/zh-CN/plugins/dsh-acp-for-bitfun/

GitHub Repository: https://github.com/bobleer/dsh-acp-for-bitfun

BitFun: https://github.com/GCWing/BitFun

DeepSeek Harness: https://github.com/deepseek-ai/deepseek-harness