Preface¶

When running a longer Agent task with DeepSeek Harness (CLI name dsh), the most common interruptions are not your active stop command, but network jitter, upstream timeouts, 5xx errors, or hitting the token output limit. The Web UI will show the round as ended, with the session log stuck at the failure point. To have the model continue working, the usual practice is to manually type and send “continue”. As tasks grow longer, this becomes a repetitive chore.

The design principle of DeepSeek Harness is “everything is a plugin”: models, tools, sessions, and UI can all be replaced at the configuration layer without modifying the core source code. As a result, a number of independent plugin directories have emerged in the community. deepseek-harness-plugin.com is a third-party collection site, not officially affiliated with DeepSeek / Fang, and should not be treated as an official app store. The dsh-auto-continue introduced in this article is listed in the “UI Enhancement” category of this directory.

Below is a collation cross-referenced with the directory details page, GitHub repository README, package.json, and npm page: what it is, which errors it will automatically resume from, how to install it, and how to configure it.

What it is¶

dsh-auto-continue is a Web UI plugin for dsh web, maintained by HsiangNianian, licensed under MIT. The npm package name is dsh-client-auto-continue, with the current version 0.6.0 (released 2026-08-16). As of 2026-08-17, the GitHub repository has 23 stars; the community directory page still shows 12 stars at the same time, so the repository’s first-hand data shall prevail.

The problem it solves is very specific: when a request in the Web GUI is interrupted for non-human reasons, the plugin simulates the user entering and sending “continue” in the browser. This message will appear in the session log and is visible to the model, with the same effect as clicking send manually, allowing the interrupted work to resume.

It is not the Agent loop itself, nor does it modify the Harness core. The plugin attaches additional event listeners on the browser side, then calls the same sessions.prompt used by the “Send” button. The repository README explicitly states: it does not touch files, credentials, or access networks outside the dsh host.

Core Features¶

The repository makes recovery policies configurable, with the following default behaviors.

Error Classification¶

After enabling classification (enabled by default), the plugin will only automatically resume temporary failures, such as network errors, timeouts, 5xx errors, and 429. The following will be treated as permanent errors, skipping automatic resumption and triggering notifications:
- HTTP status codes 401 / 403
- Code or message matching keywords for authentication, credentials/API Key, balance/quota, model not found, context length limit, etc.

If classification is turned off, all interruptions that meet the trigger conditions will be automatically resumed. Retrying issues like authentication failures or exhausted quotas is usually pointless, so excluding them by default is reasonable.

Adaptive Backoff¶

When a session fails consecutively, the waiting time increases by “cooldown × coefficient”. The default cooldown is 20 seconds, with a coefficient of 2, meaning 20s → 40s → 80s, with an upper limit of 300000 ms (5 minutes) by default. Failed attempts are also counted towards the cooldown to avoid sending continuous requests to an already faulty upstream service.

Templated “Continue” Text¶

The default sent text is “Continue”. continueText supports placeholders to include failure context in the resumption message, for example:

Continue ({tool}: {code})

Available placeholders include {code}, {message}, {status}, {tool} (the last tool call before failure), {turn}, {errorCount} (number of consecutive failures including this one), {sessionTitle}, and {elapsed} (time elapsed since failure, e.g. 1m5s). When the output token limit is reached, another template continueTextMaxTokens is used, with the example given in the README being “Continue outputting, do not repeat the generated content”.

Idempotency Guardrails¶

Before resuming, you can check the previous tool call to avoid re-running operations that “may have already been executed”:
- Result not confirmed (the round died mid-tool execution, e.g. a git push where it’s uncertain if the push was completed): Prompt the model to confirm the status first and do not repeat execution
- Tool confirmed successful completion: Indicates the task is already finished, do not repeat
- Tool failed: No guardrails, since retrying is the intended purpose

Both guardrail texts can be modified, supporting {tool} / {result} placeholders.

Pause, Notifications, and Statistics¶

There is a global “Pause Auto-Continue” switch in the settings card, which will immediately stop real-time listening and scanning once enabled. Notifications also allow pausing a single session for 1 hour, or clicking “Resume Now” (ignoring cooldown and consecutive attempt limits).

The card also shows today’s statistics: number of auto-continues, successful recoveries, post-resumption failures, permanent skips, and limit-stopped sessions, with distribution viewable by error code and one-click reset. Browser notifications are off by default; when enabled, you will be alerted when auto-continuation succeeds, is abandoned, or encounters a permanent error. Permission is requested on first use, and will not pop up again if denied.

Which Events are Monitored¶

The plugin opens two additional SSE connections in the browser: events.mux (session events) and events.host (host events). The host supports multiple consumers and will not crowd out the built-in runtime. It reacts to the following end states:

The following cases will not be automatically resumed: user-initiated stop (aborted), policy rejection (blocked); interrupted in real-time streams (this tag is only written by crash recovery during host reload, orphaned rounds go through startup scan, not real-time paths); sessions that the host has already recovered; sessions that are running or have queued messages; sub-agent sessions; sessions in cooldown period or that have reached the consecutive attempt limit.

After detecting an interruption, the plugin waits for a grace period (3 seconds by default). If the host initiates a new round (turn/start) during this time, the auto-continuation is canceled, then sessions.prompt is called in queue mode.

When the page loads or reconnects, it will also scan recently updated sessions: the last round ended within the scan window (default 15 minutes) for non-human reasons, and there have been no new turn/start or user messages since, will also be resumed. This covers scenarios like “browser closed, host crashed”. When multiple tabs are open, a localStorage mutex plus per-session cooldown records ensure only one tab sends, avoiding duplicate “continue” messages.

Installation and Activation¶

DSH plugins are installed into profiles. The profile corresponding to dsh web is the web profile. You will need to restart dsh web after installation.

The installation command given on the community directory page is as follows, which can be executed in the DeepSeek Harness terminal:

dsh plugin add github:HsiangNianian/dsh-auto-continue

The directory page also reminds users: for reproducible installations, please pin the commit hash. The latest commit on the main branch is currently 98181b0e5e0afd33ca89b314fc3957a2634602e4 (upgraded version to 0.6.0), written as:

dsh plugin add github:HsiangNianian/dsh-auto-continue#98181b0e5e0afd33ca89b314fc3957a2634602e4

The repository README provides more complete guidance: the plugin needs to go into the web profile, and recommends using npm first (package name dsh-client-auto-continue). Installing from the GitHub default branch will track main, suitable for keeping up with the latest changes; for relative stability, use npm.

# Recommended by README: Install from npm
dsh plugin --profile web add dsh-client-auto-continue
dsh web

# Or install directly from GitHub (build artifacts are committed, no local clone required)
dsh plugin --profile web add github:HsiangNianian/dsh-auto-continue
dsh web

Local installation from the repository requires Node.js ≥ 18, first run npm install and npm run build, then use dsh plugin --profile web add link:$(pwd). The package includes cordis.patch.yml, which will be automatically registered in the plugin line.

Verify that the configuration layer is attached:

dsh --profile web --dump-config | grep auto-continue

A log similar to [auto-continue] Started (text="Continue", …) should appear in the browser console (Ctrl/Cmd+Shift+I). Additional logs will be printed each time an interruption is detected and an automatic send is performed.

To uninstall (for npm/repository installations):

dsh plugin --profile web remove dsh-client-auto-continue
dsh web

Typical Usage¶

After installation and opening dsh web, the plugin works with default values: wait 3 seconds after an interruption, send “Continue” if the host does not recover on its own; a maximum of 3 consecutive automatic resumes per session; only resume temporary errors.

To modify behavior, open Settings → Plugins and find the dsh-client-auto-continue configuration card. Changes to the card are temporary until you click “Save” to write them to disk. You can also directly edit the auto-continue section in ~/.dsh/settings.yaml; the file is monitored, and changes will take effect immediately; if the open page does not respond, restart dsh web. Below is the default configuration given in the README, with unfilled fields falling back to these values:

auto-continue:
  paused: false
  continueText: 'Continue'
  continueTextMaxTokens: 'Continue'
  guardTools: true
  guardPendingText: '(The previous tool "{tool}" may not have completed, confirm the status first before continuing, do not repeat execution)'
  guardDoneText: '(The previous tool "{tool}" has completed, result: {result}; do not repeat execution, continue directly)'
  graceMs: 3000
  cooldownMs: 20000
  maxConsecutive: 3
  scanOnBoot: true
  scanLimit: 8
  freshMs: 900000
  reconnectScanDelayMs: 5000
  reconnectBackoffMs: 3000
  verbose: true
  classify: true
  backoffFactor: 2
  backoffMaxMs: 300000
  notify: false

Several common modifications:
1. To resume after token limit is reached and avoid repeating generated content, change continueTextMaxTokens to the prompt from the README example.
2. To include the failure reason in the resume message, change continueText to Continue ({tool}: {code}).
3. To temporarily turn off auto-resumption, set paused to true, or enable “Pause Auto-Continue” in the settings card.
4. Enable notify for desktop alerts.

The repository README also mentions a known limitation in DSH 0.1.0-rc.6: the Web UI settings area currently only exposes namespaces hardcoded in the whitelist of the @deepseek-ai/dsh-host-apiproxy package. Before upstream changes to use settings.register()-driven configuration, if the card does not appear, you can run an idempotent patch to make all plugin-registered namespaces visible:

npx --yes --package dsh-client-auto-continue patch-expose
dsh web

The auto-resume engine itself does not depend on this patch; it only affects whether the GUI settings area is displayed. If the patch fails, you can directly edit ~/.dsh/settings.yaml. You will need to run this script again after reinstalling dsh.

Applicable Scenarios and Notes¶

It is suitable for users who are already using dsh web, whose tasks are frequently interrupted by network or timeout issues, and who do not want to manually type “Continue” every time. It only acts on Web UI sessions, will not resume sub-agents, and will not force retries when the user actively stops or the policy intercepts the request.

Pay attention to these points before use:
1. Permissions and Source. 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. The license verified in this article is MIT, and the source code is at HsiangNianian/dsh-auto-continue. The community directory page also includes this same warning.
2. It will not make judgments on whether the task should continue for you. Classification can block permanent errors such as authentication, balance, and model not found, but after a temporary failure is resumed, the model may still repeat or misconnect the context. The idempotency guardrails only prompt in the resume text, and do not perform transaction rollbacks.
3. Consecutive Limit. By default, a session will stop after 3 consecutive automatic resumes, until you intervene or a successful round occurs. When the upstream service continues to fail, you should first check the network and API, rather than increasing maxConsecutive to a large value.
4. Settings card may not appear. If you are using a dsh version around 0.1.0-rc.6, follow the patch procedure in the previous section, or edit the YAML file directly.
5. Configuration sections will remain in ~/.dsh/settings.yaml after uninstallation. The repository states this is harmless, and you need to delete them manually if you want to clean up.

Summary¶

dsh-auto-continue does one narrow thing: automates the step of “manually typing ‘Continue’ to resume a round interrupted by network or other reasons” in dsh web, paired with error classification, backoff, guardrails, and startup scanning. It does not replace your judgment on the correctness of the task, only reduces repetitive manual sends.

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

GitHub: https://github.com/HsiangNianian/dsh-auto-continue

npm: https://www.npmjs.com/package/dsh-client-auto-continue