Preface

If you have integrated custom API models into DeepSeek Harness (DSH), you have likely encountered two problems: one is that the official settings do not have an entry for configuring reasoning levels for custom models, so you have to manually modify the configuration to enable the high or max tiers; the other is that every time you switch channels or create a new session, the model and reasoning intensity revert to default values, and previous preferences are not remembered. The same goes for channel-level retry strategies; the default behavior may not fit your network environment.

The dsh-model-memory introduced below is a DSH plugin written to solve these issues. It mounts a reasoning level configuration panel for custom API models in the official DSH “Settings -> Models” section, simultaneously remembers the last selected model and reasoning intensity for each channel across sessions, and provides channel-level retry strategy configuration.

What is it

dsh-model-memory is a DSH plugin designed to manage reasoning levels for custom API models, configure channel retry strategies, and persist preferences. It is maintained by Mutx163, written in TypeScript, open-sourced under the MIT license, current version 0.1.12, requires Node.js >= 20, and the client platform is web.

DSH’s philosophy is “everything is a plugin”. This plugin follows this approach: it does not modify the main interface structure but embeds functionality into official settings items. It mounts based on an independent local project and the DSH Profile symlink mechanism, so upgrading the DSH global scaffold will not result in the loss of the plugin and configuration.

Core Features

Custom Model Reasoning Level Configuration

  • In the official DSH “Settings -> Models”, when expanding a custom API model, the reasoning level configuration panel is automatically mounted.
  • Supports one-click enabling of supportsReasoningEffort for the model and checking reasoning tiers: low / medium / high / max.
  • After clicking save, it writes atomically to ~/.dsh/settings.yaml with instant hot reload, no restart required.

There is a fault-tolerant design for the configuration write path: it prioritizes the host’s settings service, falling back to atomic file direct writing if the host service is missing, ensuring the configuration is definitely persisted to disk.

Cross-Session Preference Memory

  • Precise recording per channel: records the last selected model and its configured reasoning intensity for each channel across sessions.
  • Auto-fill: when switching channels or creating a new session, it automatically restores the historical model and reasoning intensity preferences for that channel, no longer reverting to the default basic intensity.

Persistence storage is handled by an independent storage engine, with the disk path being ~/.dsh/model-memory.json.

Channel-Level Request Retry Policy

Three modes are available:

  • Channel Default: Retry up to 5 times after failure.
  • Infinite Retry: Keep retrying after failure until success or manual cancellation.
  • Custom Count: Specify the number yourself, 0 means no retry.

retryPolicy is configured per channel and shared by all models within that channel. When updating, it preserves the existing backoff parameters for that channel. The write path is consistent with the reasoning level configuration (host settings service priority, falling back to atomic file direct writing if missing).

UI & Upgrade

  • The plugin does not add redundant buttons, keeping the main interface in its native style.
  • Based on an independent local project and the DSH Profile symlink mechanism, upgrading the DSH global scaffold will not lose the plugin and configuration.

Installation & Enablement

Installation from NPM is recommended. Execute the following command to mount the plugin to DSH’s Web Profile:

dsh plugin --profile web add dsh-model-memory

After installation, the reasoning level configuration panel will appear in the official DSH “Settings -> Models”. Expand a custom API model to see it.

Local Development & Debugging

If you want to modify code locally or do secondary development, you can mount via symlink. First clone the repository, install dependencies, and complete a full verification:

git clone https://github.com/Mutx163/dsh-model-memory.git
cd dsh-model-memory
pnpm install
pnpm run verify

pnpm run verify will execute type checking, unit tests, and packaging/building in sequence, with artifacts output to lib/. Then mount the local directory to the DSH Web Profile as a symlink:

dsh plugin --profile web add link:/path/to/dsh-model-memory

Common commands used during daily development:

# TypeScript type checking
pnpm run typecheck

# Run full Vitest unit tests
pnpm run test

# Full verification and packaging/building
pnpm run verify

The project also depends on js-yaml ^5.3.0. Peer dependencies include @deepseek-ai/cordis (>=4.0.1 <4.1.0) and @deepseek-ai/dsh-agent (>=0.1.1-rc.1 <0.2.0).

Use Cases & Precautions

Suitable for these types of users:

  • Users who have integrated custom API models into DSH and need to manually specify reasoning tiers (e.g., max).
  • Multi-channel users who want each channel to remember the last selected model and reasoning intensity, rather than setting everything from scratch for every new session.
  • Scenarios with clear requirements for request retry behavior, such as wanting infinite retries in unstable network conditions, or wanting to set no retries in billing-sensitive scenarios.

Before installation, there are a few points to confirm:

  • The plugin runs with the permissions of the current dsh process and will read/write local files like ~/.dsh/settings.yaml and ~/.dsh/model-memory.json. You should check the source code and license before installing to ensure the behavior meets expectations.
  • The plugin client platform is web and needs to be mounted to the Web Profile to be used.
  • The project is open-sourced under the MIT license. The protocol information is consistently declared in the README badges, LICENSE file, and package.json.

Conclusion

What dsh-model-memory does is not complicated: it fills in the missing reasoning level configuration for DSH custom models, remembers channel and reasoning intensity preferences across sessions, and exposes retry strategies to the channel level. All three things are within the official settings interface, the configuration is written atomically, and upgrading the scaffold won’t lose data.

Project URL: https://github.com/Mutx163/dsh-model-memory

Community Directory Page: https://www.skillhub.cn/plugins/Mutx163/dsh-model-memory (The community directory is an independent site and has no official affiliation with DeepSeek or Hypothesis.)