dsh-subagent-model-picker

dsh-subagent-model-picker

The visual, manual subagent-model selector for DeepSeek Harness.

Pick a cheaper / faster model — and its reasoning effort — for every in-process subagent, right beside the main model seat, per session, with zero guessing.

Why this exists

"Route subagents to a cheaper model" has been done many ways in the last few days, but they all decide *for* you:

dsh-subagent-model-picker is the only visual, manual selector in this category: a GUI control next to the main model seat, so the choice is explicit, visible at a glance, and applies deterministically to every subagent path.

What it gives you

• Manual — you choose; not a policy, not the model itself.
• Visual — a dropdown beside the main model seat (hover pill + click-outside-to-close + Escape).
• Predictable — the selection is per-session state; every child gets exactly what you picked.
• Global coverage — one host-side agent/request listener covers subagent, subagent_fork, and workflow fan-out children at any depth.
• Reasoning effort — models that expose effort levels (e.g. off / high / max) get a matching "Thinking effort" menu.
• Inherit by default — subagents stay on the main model until you opt in.
• Per-session + durable — the choice follows the session and survives restart.
• Localised — zh / en UI copy.

Complementary, not a replacement

Auto-routing plugins (tier/smart/adaptive routers, plan-mode classification) and tool/command approaches answer *"pick for me"*. This plugin answers *"let me pick"*. They compose: keep an auto-router as the default policy and use the picker to override a specific session manually — or the other way around.

How it works

Two halves cooperate without touching the apiProxy settings whitelist:

1. Host (lib/index.js) registers one agent/request waterfall listener.

dsh-scope admits events *up* the scope chain, so this host-root listener sees every agent's requests; a child is recognised by agent.options.subagentDepth >= 1. It walks the parent chain to the root session and overrides { provider, model, reasoningEffort? } only for subagents.

1. Persistence + transport go through a Typert Remote service

(subagent-model-picker, wire namespace subagent-model-picker) exposing get / set / clear. The client half mounts the Remote contribution (ctx.remote.$mount) and calls remote.subagent-model-picker.*; the service persists the sessionId -> { provider, model, reasoningEffort? } map host-side, so the apiProxy exposedNamespaces() whitelist is never consulted.

Install

One-liner (GitHub, market-compatible)

dsh plugin --profile web add github:ringoage/dsh-subagent-model-picker

This is the same github: install path the DSH plugin market uses, so it can be installed straight from this repository.

Manual (edit the profile)

In your web profile (.dsh/profiles/web/package.json), add the package as a dependency and list it in dsh.profile.bundles:

{
  "dependencies": {
    "dsh-subagent-model-picker": "^1.0.0"
  },
  "dsh": {
    "profile": {
      "bundles": ["dsh-subagent-model-picker"]
    }
  }
}

Then restart the harness. For a local checkout use a link: dependency pointing at this directory.

Usage

To the left of the main model selector you will see Subagent Model (or 子代理模型). Pick a model — and, if offered, a Thinking effort — and every subagent spawned from that session uses it. Choose Inherit main model (default) to restore default routing.

Limitations

• Only in-process subagents are routed: subagent, subagent_fork, and

workflow fan-out children driven by DSH itself. External CLI agents (e.g. claude-code, codex) manage their own model selection and are not affected.

• The selector is a web client feature; host routing works regardless of

whether the web GUI is open, but the selection itself is edited from the web composer.

Development

• lib/index.js — host half (Remote service + agent/request routing).
• lib/client.js — client half (slot UI + Remote contribution + locale).
• cordis.patch.yml — the dsh.bundle.patch insert that mounts the plugin row.

The Remote service runs in SRC mode: methods are marked with the @Remote(name) contract applied in plain JS (no generated typert.host.js), and the client contribution ships hand-written strict descriptors.

License

MIT