Preface¶

DeepSeek Harness (dsh) splits the agent runtime into replaceable plugins: model adapters, tools, sessions, and interfaces can all be attached or swapped out. The official summary is “Everything is a plugin”. During the developer preview stage, a very specific pain point will quickly arise: if the main model uses a plain text routing, screenshots, error interfaces, UI drafts pasted into the chat dialog will be blocked by the api-proxy’s access gate, and the pixel data will not enter the session, making it impossible for the text model to “see” these images.

The community plugin dsh-read-image provides a plug-and-play patch for this issue: without modifying any presets, it brings images into the session and projects them as [Image #N], then uses the first-class citizen read_image tool in conjunction with a configurable vision model to parse the images back into text. This article is collated after cross-checking with the community plugin directory details, the GitHub repository’s README, package.json, LICENSE, and the DeepSeek Harness official repository. It should be noted that deepseek-harness-plugin.com is an independently operated community directory, and the site itself states that it has no official affiliation, endorsement, or sponsorship relationship with DeepSeek / Fanfou, and is not an official app store.

What is this¶

dsh-read-image is a “Session & Message” type DeepSeek Harness plugin, maintained by OoWJZZoO, with its repository at github.com/OoWJZZoO/dsh-read-image, licensed under MIT. The npm package name is @deepseek-ai/dsh-read-image, current version 0.1.0, main language is JavaScript. The community directory included it on 2026-08-15; as of 2026-08-18, the GitHub star count is 3. The dsh.client.platform field in package.json is declared as web, and the installation instructions also revolve around the web profile.

It does not aim to “build another multi-modal chat window”, but addresses three specific issues written in the README:
- Plain text routing will no longer be blocked when users send images
- In requests sent to the text API, image blocks will be replaced with [Image #N], and pixel data will not enter the text model
- Agents can call read_image by session index or file path, and the vision model you configure will convert the image into a text description

It requires DeepSeek Harness 0.1.0-rc.6 or higher. Harness is still in developer preview, and the README notes that updated release candidates may require compatibility adjustments.

Core Features¶

Allow images through text routing¶

When a user sends an image, the plugin wraps llm.resolveModelInfo to let the text routing externally declare that it can accept image inputs, so the api-proxy’s access gate will放行 the request. When the plugin is uninstalled, the original declaration will be restored. The capability truth table is built using the original resolveModelInfo before wrapping, avoiding disguising itself as a “natively multi-modal” model before making judgments based on that.

[Image #N] projection¶

On the text routing, image blocks in model requests will be synchronously replaced with [Image #N] text before being re-dispatched; pixel data will not enter the text API. Multi-modal routings that have natively declared image input will be放行 as-is. The session log remains the source of truth: image references are still persisted normally, and the replacement only occurs at the model’s visible boundary.

First-class citizen read_image tool¶

Each session automatically registers the read_image tool upon session/created and shadows the built-in同名 tool of the harness. The tool description will interpolate the current real default values, so agents do not need to guess the configuration. The parameters are as follows:
- image_index: Read the Nth image in the session (corresponding to [Image #N])
- file_path: Read a local image by path, in PNG / JPEG / WebP / GIF format
- prompt / reasoning_effort / timeout_ms / max_tokens / max_thinking_tokens: Optional overrides; if omitted, the configured default values will be used

Under the text routing, the configured vision model will convert the image into a text description and return it; under the native multi-modal routing, the tool will directly return the image itself. The call is stateless, and the same image can be read repeatedly.

When the base routing of the session has already declared image input (the README uses mimo-v2.5 as an example), the plugin will not register a custom tool or inject the [Image #N] prompt segment. In this routing, images directly enter the model context, and the model will see the harness’s built-in read_image (only file_path, which means returning the image itself).

Settings page and hot reload¶

After entering the settings via the sidebar gear, there is a “Image Reading” page for selecting the vision model and default parameters. The configuration base is $DSH_HOME/settings.yaml (if DSH_HOME is not set, Linux / macOS uses ~/.dsh/settings.yaml, Windows uses %USERPROFILE%\.dsh\settings.yaml), and it supports hot reload without restarting. The web side writes to the user layer, overriding the corresponding items in the yaml file.

The browser settings protocol has a whitelist for plugin namespaces (WEB_SETTINGS_NAMESPACES), and the plugin’s own settings.register() will only get settings-not-exposed from the client. Therefore, the “Image Reading” page does not use this protocol, but reads and writes the same namespace via the host-side typert Remote bridge readImageConfig.get/set, sharing a single configuration between headless and web.

Startup self-check¶

The plugin will detect the harness’s internal contracts it depends on. If any check fails, it will fail safely: no capabilities will be mounted, and the harness will start normally. The full diagnostic log will be written to ~/.dsh/logs/dsh-read-image-guard.log (Windows uses %USERPROFILE%\.dsh\logs\dsh-read-image-guard.log), and only a short prompt will be displayed in the foreground. To disable the self-check, set guard.enabled to false in the dsh-read-image section, and the README notes that this is at your own risk.

Installation and activation¶

The installation command given on the community directory page is as follows, run it in the DeepSeek Harness terminal:

dsh plugin add github:oowjzzoo/dsh-read-image

The repository README recommends explicitly installing it to the web profile (the GitHub username case is OoWJZZoO; GitHub is case-insensitive, and oowjzzoo on the directory page points to the same repository):

dsh plugin --profile web add github:OoWJZZoO/dsh-read-image

Then restart dsh web. This package includes cordis.patch.yml via the dsh.bundle manifest, and the profile bundle mechanism will automatically synthesize the plugin line without manually modifying the patch.

For reproducible installations, the directory page recommends pinning the commit hash. As of 2026-08-18, the latest commit on the repository’s main branch is fa0bab0b1ffbf4b0320fc43d064719ea7276543a (2026-08-15, added Windows path instructions):

dsh plugin add github:oowjzzoo/dsh-read-image#fa0bab0b1ffbf4b0320fc43d064719ea7276543a

For manual installation, add the dependency to ~/.dsh/profiles/web/package.json, then insert the plugin line in cordis.patch.yml. The README pins the dependency to the tag v0.1.0:

"@deepseek-ai/dsh-read-image": "github:OoWJZZoO/dsh-read-image#v0.1.0"

cd ~/.dsh/profiles/web && pnpm install

- insert:
    - id: read-image
      name: '@deepseek-ai/dsh-read-image'
      config: {}

Do not use both methods at once: dsh plugin add has already synthesized the plugin line, and manually adding the dependency and inserting the same line will register the plugin twice.

After installation, you need to declare image input capability for the vision model and tell the plugin which routing and model to use:

# 1) Declare image input capability for the vision model (pi-ai routing)
llm-pi-ai:
  providers:
    <your-provider>:
      models:
        - id: <your-vision-model>
          input: [text, image]

# 2) Configuration for this plugin
dsh-read-image:
  visionProvider: <your-provider>
  visionModel: <your-vision-model>

visionModel must declare input: [text, image]. You can also select the provider and model in the web’s “Settings → Image Reading” page, and the dropdown options come from the “Models” page. The remaining keys and their README default values are as follows:

Typical usage¶

After pasting an image, the text model will see [Image #1], and the agent can call the tool to read it:

read_image image_index=1

Read a workspace or local file:

read_image file_path=/path/to/image.png

Both C:\Users\... and C:/Users/... are acceptable on Windows, and backslashes are handled by the harness file service. The plugin runs as pure Node.js, and the README notes that it is fully usable on Windows; ~/.dsh corresponds to %USERPROFILE%\.dsh.

If you need to ask questions about this specific image, or temporarily modify the thinking intensity, timeout, token limit, you can pass prompt, reasoning_effort, timeout_ms, max_tokens, max_thinking_tokens to override the default values. The same image can be called multiple times.

Applicable scenarios and notes¶

It is suitable for DSH users whose main model is plain text, but occasionally need to view screenshots, error interfaces, UI drafts or local image files in the session. Sessions that are already working on native multi-modal routings (such as mimo-v2.5 mentioned in the README) will not go through the [Image #N] projection, and will not need this custom toolset.

Before using it, you need to prepare a vision model that has declared input: [text, image] and fill in visionProvider / visionModel. The plugin reuses the credentials, retries, and logging of ctx.llm, and the vision call follows the link you have already configured in the harness, and is not a built-in free image recognition service.

Both the directory page and the official plugin installation instructions emphasize: the plugin runs with the permissions of the current dsh process, and may execute code during installation. You should check the source code repository and license before installing. This plugin is MIT licensed, with its source code in the aforementioned GitHub repository; plugins from GitHub may also run build scripts during installation, and you should only install sources you trust, and pin the commit for reproducible installations.

A few more boundary notes from the README:
- It depends on the harness’s internal contracts, and its form may change after version upgrades; the plugin will not load if the self-check fails, do not assume “it will work once installed”
- guard.enabled: false will skip the safety fuse, only use it when you understand the risks
- Do not overlap dsh plugin add with manually modifying package.json / cordis.patch.yml
- The development/deployment scripts scripts/*.sh are POSIX bash, you need to use Git Bash / WSL / MSYS2 on Windows, or manually copy package.json, lib/ and cordis.patch.yml according to the README

Summary¶

dsh-read-image builds a very narrow bridge: plain text DSH sessions can accept images, the model side only sees [Image #N], and the actual image parsing is handed over to the vision model and read_image tool you specify. No presets need to be modified, the web settings page can directly modify the default parameters, and there is a contract self-check during startup.

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

GitHub: https://github.com/OoWJZZoO/dsh-read-image