dsh-plugin-subagent-bridge 0.7.3 → 0.8.0

package/README.md

@@ -2,6 +2,8 @@
 
 [![license](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 [![dsh](https://img.shields.io/badge/DSH-%5E0.2.1--0-2f6fed)](https://github.com/deepseek-ai/deepseek-harness)
+<!-- M8ven ownership proof — keep this line in place; it verifies the publisher. -->
+[![M8ven Score](https://m8ven.ai/badge/mcp/dogtiti-dsh-plugin-subagent-bridge-8a3t8k?v=f15f3e56c3fa22e8aafb88cf5428501f)](https://m8ven.ai/mcp/dogtiti-dsh-plugin-subagent-bridge-8a3t8k?s=readme)
 
 在 DeepSeek Harness 宿主内部提供**本机回环 MCP 端点**，让另一个智能体（如 Codex）把任务派给 DSH 会话并取回结果。
 
@@ -9,6 +11,23 @@
 
 ---
 
+## 指定模型
+
+`dsh_task`、`dsh_spawn`、`dsh_followup` 都可以带 `model`，让 worker 跑在指定模型上：
+
+```js
+dsh_task({ prompt: "…", model: "zai-coding-cn/glm-5.3", reasoningEffort: "max" })
+dsh_spawn({ task_name: "review", message: "…", model: "opencode-go/deepseek-v4.1-flash" })
+dsh_followup({ worker: "review", message: "…", model: "deepseek-account/deepseek-flash" })
+```
+
+- 写法是 `provider/model`；**只写模型名**时沿用当前默认 provider（`model: "glm-5.3"`）；
+- `reasoningEffort` 可选，取值随模型（`low` / `medium` / `high` / `max` 等）；
+- 不传 `model` 就完全不动会话，行为和以前一致；
+- 实测（Host 侧 `sessionController.selectModel`）：请求头里的 provider/model 确实变成指定的那组，且**不会改写 profile 的默认模型**。
+
+实现上就是在建好会话、发第一个 prompt **之前**调一次 `selectModel`，所以 worker 的第一轮就已经在新模型上跑。
+
 ## 工具
 
 | 工具 | 作用 |
@@ -246,6 +265,7 @@ node --test "test/*.test.mjs"
 | [dsh-plugin-composer-history](https://github.com/Dogtiti/dsh-plugin-composer-history) | 输入框中按 `↑` / `↓` 回填历史消息 |
 | **dsh-plugin-subagent-bridge**（本仓库） | 让 Codex 通过本机 MCP 把 DSH 当 subagent 用（spawn / wait / followup），反向也能把任务派给 Codex |
 | [dsh-plugin-usage-panel](https://github.com/Dogtiti/dsh-plugin-usage-panel) | 在模型选择器旁显示供应商套餐额度余量（目前 GLM Coding Plan），点开是明细浮层 |
+| [dsh-plugin-provider-icons](https://github.com/Dogtiti/dsh-plugin-provider-icons) | 在模型名旁显示供应商品牌 logo（24 个厂商，支持前缀匹配） |
 
 
 ## 许可

package/index.js

@@ -94,6 +94,15 @@ const TOOLS = [
           description: 'Continue an existing idle session (multi-turn worker) instead of opening a new one.',
         },
         agentPreset: { type: 'string', description: 'Agent preset for a new session.' },
+        model: {
+          type: 'string',
+          description:
+            'Model to run this worker on, as "provider/model" (for example "zai-coding-cn/glm-5.3"). A bare model id keeps the current default provider. Omit to use whatever the session already uses.',
+        },
+        reasoningEffort: {
+          type: 'string',
+          description: 'Reasoning level for `model`, if that model offers levels (low, medium, high, max...).',
+        },
         timeoutSeconds: { type: 'number', description: 'How long to wait for the turn to finish. Default 300, max 600.' },
       },
       required: ['prompt'],
@@ -116,6 +125,12 @@ const TOOLS = [
         },
         from: { type: 'string', description: 'Session id to fork when fork_turns is "all".' },
         cwd: { type: 'string', description: 'Working directory for a fresh worker.' },
+        model: {
+          type: 'string',
+          description:
+            'Model for this worker, as "provider/model" (for example "opencode-go/deepseek-v4.1-flash"). A bare model id keeps the current default provider.',
+        },
+        reasoningEffort: { type: 'string', description: 'Reasoning level for `model`, when that model offers levels.' },
       },
       required: ['task_name', 'message'],
       additionalProperties: false,
@@ -130,6 +145,11 @@ const TOOLS = [
       properties: {
         worker: { type: 'string', description: 'task_name from dsh_spawn, or a session id.' },
         message: { type: 'string', description: 'Follow-up work order.' },
+        model: {
+          type: 'string',
+          description: 'Switch this worker to another model before the turn, as "provider/model". Omit to keep its current one.',
+        },
+        reasoningEffort: { type: 'string', description: 'Reasoning level for `model`, when that model offers levels.' },
       },
       required: ['worker', 'message'],
       additionalProperties: false,
@@ -483,12 +503,37 @@ async function callTool(id, params, api, signal) {
         if (forkTurns === 'all' && (typeof args.from !== 'string' || args.from === '')) {
           throw new Error('from is required when fork_turns is "all"')
         }
-        return ok(id, text(await api.spawn({ taskName, message, forkTurns, from: args.from, cwd: args.cwd })))
+        return ok(
+          id,
+          text(
+            await api.spawn({
+              taskName,
+              message,
+              forkTurns,
+              from: args.from,
+              cwd: args.cwd,
+              model: typeof args.model === 'string' && args.model !== '' ? args.model : undefined,
+              reasoningEffort:
+                typeof args.reasoningEffort === 'string' && args.reasoningEffort !== '' ? args.reasoningEffort : undefined,
+            }),
+          ),
+        )
       }
       case 'dsh_followup': {
         const worker = requireString(args.worker, 'worker')
         const message = requireString(args.message, 'message')
-        return ok(id, text(await api.followup({ worker, message })))
+        return ok(
+          id,
+          text(
+            await api.followup({
+              worker,
+              message,
+              model: typeof args.model === 'string' && args.model !== '' ? args.model : undefined,
+              reasoningEffort:
+                typeof args.reasoningEffort === 'string' && args.reasoningEffort !== '' ? args.reasoningEffort : undefined,
+            }),
+          ),
+        )
       }
       case 'dsh_close': {
         const worker = requireString(args.worker, 'worker')
@@ -520,6 +565,9 @@ async function callTool(id, params, api, signal) {
               cwd: typeof args.cwd === 'string' && args.cwd !== '' ? args.cwd : undefined,
               sessionId,
               agentPreset: typeof args.agentPreset === 'string' && args.agentPreset !== '' ? args.agentPreset : undefined,
+              model: typeof args.model === 'string' && args.model !== '' ? args.model : undefined,
+              reasoningEffort:
+                typeof args.reasoningEffort === 'string' && args.reasoningEffort !== '' ? args.reasoningEffort : undefined,
               timeoutSeconds,
             }),
           ),
@@ -591,7 +639,7 @@ export function createApi(ctx, state, settings) {
       })
     },
 
-    async spawn({ taskName, message, forkTurns, from, cwd }) {
+    async spawn({ taskName, message, forkTurns, from, cwd, model, reasoningEffort }) {
       const service = controller()
       if (service === undefined || service === null) throw new Error('session controller is unavailable')
       if (state.workers.has(taskName)) throw new Error(`task_name ${JSON.stringify(taskName)} is already in use`)
@@ -616,6 +664,7 @@ export function createApi(ctx, state, settings) {
         if (typeof sessionId !== 'string' || sessionId === '') throw new Error('session controller did not return a session id')
       }
 
+      const appliedModel = await applyModelSpec(ctx, sessionId, model, reasoningEffort)
       const before = Number(sessions()?.get?.(sessionId)?.seq ?? 0)
       const requestId = randomUUID()
       const accepted = await service.prompt(
@@ -634,15 +683,22 @@ export function createApi(ctx, state, settings) {
         updatedAt: Date.now(),
       })
       await saveWorkers(settings, state)
-      return { task_name: taskName, sessionId, accepted: accepted?.accepted === true, fork_turns: forkTurns }
+      return {
+        task_name: taskName,
+        sessionId,
+        accepted: accepted?.accepted === true,
+        fork_turns: forkTurns,
+        ...(appliedModel === undefined ? {} : { model: appliedModel }),
+      }
     },
 
-    async followup({ worker, message }) {
+    async followup({ worker, message, model, reasoningEffort }) {
       const target = resolveWorker(state, worker)
       if (target === undefined) throw new Error(`unknown worker ${JSON.stringify(worker)}`)
       const service = controller()
       if (service === undefined || service === null) throw new Error('session controller is unavailable')
       takeDispatchSlot(state, settings)
+      const appliedModel = await applyModelSpec(ctx, target.sessionId, model, reasoningEffort)
       const before = Number(sessions()?.get?.(target.sessionId)?.seq ?? 0)
       const requestId = randomUUID()
       const accepted = await service.prompt(
@@ -656,7 +712,12 @@ export function createApi(ctx, state, settings) {
         target.record.updatedAt = Date.now()
       }
       await saveWorkers(settings, state)
-      return { worker: target.taskName ?? target.sessionId, sessionId: target.sessionId, accepted: accepted?.accepted === true }
+      return {
+        worker: target.taskName ?? target.sessionId,
+        sessionId: target.sessionId,
+        accepted: accepted?.accepted === true,
+        ...(appliedModel === undefined ? {} : { model: appliedModel }),
+      }
     },
 
     async close({ worker }) {
@@ -680,7 +741,7 @@ export function createApi(ctx, state, settings) {
       return rows
     },
 
-    async task({ prompt, cwd, sessionId, agentPreset, timeoutSeconds }) {
+    async task({ prompt, cwd, sessionId, agentPreset, timeoutSeconds, model, reasoningEffort }) {
       const service = controller()
       if (service === undefined || service === null) throw new Error('session controller is unavailable')
       const seconds = Math.min(
@@ -703,6 +764,7 @@ export function createApi(ctx, state, settings) {
         throw new Error('that session is running; use dsh_dispatch plus dsh_read_result instead')
       }
 
+      const appliedModel = await applyModelSpec(ctx, targetId, model, reasoningEffort)
       const turnBefore = lastTurn(ctx, targetId)
       const before = Number(sessions()?.get?.(targetId)?.seq ?? 0)
       const finished = waitForTurnEnd(ctx, targetId, turnBefore, seconds * 1000)
@@ -745,6 +807,7 @@ export function createApi(ctx, state, settings) {
               next: `the worker is still running; do not end the turn. Call dsh_wait({targets:["${targetId}"],timeoutMs:${String(MAX_BLOCKING_SECONDS * 1000)}}) and repeat until it is not "running".`,
             }
           : {}),
+        ...(appliedModel === undefined ? {} : { model: appliedModel }),
         text: collected.text,
         truncated: collected.truncated,
         turns: lastTurn(ctx, targetId),
@@ -1014,6 +1077,61 @@ function callerDepth(state, sessionId) {
 }
 
 
+/**
+ * Read a `provider/model` spec. A bare model name keeps the provider of the current
+ * default selection, so callers can say `model: "glm-5.3"` without repeating the
+ * provider they already run.
+ * @param ctx - Host context.
+ * @param spec - `provider/model` or a bare model id.
+ * @returns {{ provider: string, model: string }} resolved pair.
+ */
+function parseModelSpec(ctx, spec) {
+  const raw = String(spec).trim()
+  if (raw === '') throw new Error('model must not be empty')
+  if (raw.startsWith('/') || raw.endsWith('/') || raw.includes('//')) {
+    throw new Error(`model must look like "provider/model", got ${JSON.stringify(spec)}`)
+  }
+  const slash = raw.indexOf('/')
+  if (slash > 0) {
+    const provider = raw.slice(0, slash).trim()
+    const model = raw.slice(slash + 1).trim()
+    if (provider === '' || model === '') throw new Error(`model must look like "provider/model", got ${JSON.stringify(spec)}`)
+    return { provider, model }
+  }
+  const current = ctx.get('agentDefaultModel')?.currentSelection?.()
+  const provider = typeof current?.provider === 'string' ? current.provider : ''
+  if (provider === '') throw new Error('model without a provider needs a default selection; pass "provider/model"')
+  return { provider, model: raw }
+}
+
+/**
+ * Install a model selection on one session before its next turn.
+ * `sessionController.selectModel` validates the pair and applies it to the next request.
+ * @param ctx - Host context.
+ * @param sessionId - session to switch.
+ * @param spec - `provider/model` or a bare model id.
+ * @param reasoningEffort - optional effort level.
+ * @returns {{ provider: string, model: string, reasoningEffort?: string } | undefined} applied selection.
+ */
+async function applyModelSpec(ctx, sessionId, spec, reasoningEffort) {
+  if (typeof spec !== 'string' || spec.trim() === '') return undefined
+  const service = ctx.get('sessionController')
+  if (service === undefined || service === null) throw new Error('session controller is unavailable')
+  if (typeof service.selectModel !== 'function') throw new Error('this Host does not expose selectModel; update DeepSeek Harness')
+  const { provider, model } = parseModelSpec(ctx, spec)
+  try {
+    const result = await service.selectModel({
+      sessionId,
+      provider,
+      model,
+      ...(typeof reasoningEffort === 'string' && reasoningEffort !== '' ? { reasoningEffort } : {}),
+    })
+    return result?.selected ?? { provider, model, ...(reasoningEffort ? { reasoningEffort } : {}) }
+  } catch (error) {
+    throw new Error(`cannot switch ${String(sessionId)} to ${provider}/${model}: ${String(error?.message ?? error)}`)
+  }
+}
+
 /**
  * Place a freshly created session in the workspace its directory belongs to.
  * `sessionController.create` only records a working directory; the sidebar groups

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-plugin-subagent-bridge",
-  "version": "0.7.3",
+  "version": "0.8.0",
   "type": "module",
   "description": "Subagent bridge: lets Codex delegate a task to DeepSeek Harness the way it would spawn a subagent (one call, waits for the answer), plus a codex_dispatch tool for the reverse direction.",
   "keywords": [

package/skills/deepseek-worker/SKILL.md

@@ -104,6 +104,23 @@ dsh_spawn({ "task_name": "continue_here", "fork_turns": "all",
 `fork_turns: "all"` 会 fork 那个会话作为 worker 的起点（继承到最近一个已完成 turn），worker 的后续改动**不会**污染原会话。默认 `"none"` 是全新空会话。
 
 
+## 让它自己并行（DSH 也有 subagent）
+
+DSH **自带** `subagent` 工具（和这座桥无关，是它自己的能力，worker 在深度 0，可以开子 agent）。但它**默认不会用**——不提示就一个人串行干完。
+
+任务能拆成互不依赖的几块时，在 prompt 末尾加一句：
+
+> 这几块互不依赖，可以用你自己的 subagent 并行处理，最后汇总。
+
+实测：4 个互不依赖的乘法 + 这句提示 → 它开了 **4 个 subagent 并行**，43 秒返回汇总，结果全对。不加这句，同样的活它串行做完。
+
+判断标准和 Codex 的 proactive 策略一致：
+
+- ✅ 子任务互不依赖、并行能省时间或提高质量 → 加这句
+- ❌ 有先后依赖、要改同一批文件、验收标准还没想清 → 不要加，串行更稳
+
+DSH 自己的委派深度上限是 1：worker（depth 0）能开子 agent（depth 1），子 agent 不能再往下开。所以不会无限递归。
+
 ## 怎么写 prompt
 
 worker **看不到你这段对话**，它只有 `prompt` 和 `cwd`。写成可以独立开工的工单：