dsh-auto-model-routing 0.5.2 → 0.5.3

package/lib/strategies/index.d.ts

@@ -4,14 +4,10 @@ export interface Registry {
     readonly strategies: readonly FamilyStrategy[];
     /** Main-model support decision; undefined means AUTO does not manage this model. */
     familyOfMainModel(model: string | undefined): FamilyStrategy | undefined;
-    /** Family of a child model on an exact transport provider. */
-    familyOfChild(provider: string, model: string): FamilyStrategy | undefined;
-    /** Child model id for a family on a transport: transport prefix + capability slot. */
-    childModel(familyId: string, provider: string, capability: Capability): string | undefined;
+    /** Catalog entry for a capability slot: same bare name (case-insensitive) and the parent's exact prefix, unique or none. */
+    resolveSlot(familyId: string, capability: Capability, parentModel: string, models: readonly string[]): string | undefined;
     effortStart(model: string): StartEffort | undefined;
-    hasProvider(provider: string): boolean;
     get(familyId: string): FamilyStrategy | undefined;
-    providers(): string[];
     ids(): string[];
     labels(): string[];
 }

package/lib/strategies/index.js

@@ -3,6 +3,8 @@ import { codex } from './codex.js';
 const CAPABILITIES = ['bounded', 'analytical', 'frontier'];
 const START_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
 const bare = (model) => model.slice(model.lastIndexOf('/') + 1);
+const prefixOf = (model) => model.slice(0, Math.max(0, model.lastIndexOf('/')));
+const KEYS = new Set(['id', 'label', 'modelPrefixes', 'effortStarts', 'childModels']);
 const overlaps = (a, b) => a.startsWith(b) || b.startsWith(a);
 /** Validates the whole list up front; any conflict throws and no partial registry exists. */
 export function createRegistry(input) {
@@ -10,10 +12,12 @@ export function createRegistry(input) {
     const ids = new Set();
     const starts = new Map();
     const prefixes = [];
-    const childPrefixes = new Map();
     for (const s of strategies) {
         if (!s.id)
             throw new Error('策略缺少 id');
+        for (const key of Object.keys(s))
+            if (!KEYS.has(key))
+                throw new Error(`策略 ${s.id} 含未知键：${key}`);
         if (ids.has(s.id))
             throw new Error(`策略 id 重复：${s.id}`);
         ids.add(s.id);
@@ -33,18 +37,12 @@ export function createRegistry(input) {
                 throw new Error(`起点键重复：${model}（${starts.get(model)} 与 ${s.id}）`);
             starts.set(model, s.id);
         }
-        for (const capability of CAPABILITIES)
-            if (typeof s.childModels?.[capability] !== 'string' || !s.childModels[capability])
+        for (const capability of CAPABILITIES) {
+            const slot = s.childModels?.[capability];
+            if (typeof slot !== 'string' || !slot)
                 throw new Error(`策略 ${s.id} 缺少能力槽：${capability}`);
-        for (const [provider, prefix] of Object.entries(s.transports)) {
-            const existing = childPrefixes.get(provider) ?? [];
-            const clash = existing.find(p => p.prefix === '' || prefix === '' ? true : overlaps(p.prefix, prefix));
-            if (clash) {
-                if (clash.prefix === '' || prefix === '')
-                    throw new Error(`provider ${provider} 的空前缀只能属于一个策略（${clash.id} 与 ${s.id} 冲突）`);
-                throw new Error(`provider ${provider} 下子模型前缀重叠：${prefix}（${s.id}）与 ${clash.prefix}（${clash.id}）`);
-            }
-            childPrefixes.set(provider, [...existing, { prefix, id: s.id }]);
+            if (slot.includes('/'))
+                throw new Error(`策略 ${s.id} 的能力槽不能含 /：${slot}`);
         }
     }
     const byId = new Map(strategies.map(s => [s.id, s]));
@@ -56,15 +54,12 @@ export function createRegistry(input) {
             const name = bare(model).toLowerCase();
             return strategies.find(s => s.modelPrefixes.some(p => name.startsWith(p.toLowerCase())));
         },
-        familyOfChild: (provider, model) => {
-            const entries = childPrefixes.get(provider) ?? [];
-            const hit = entries.find(e => e.prefix !== '' && model.startsWith(e.prefix)) ?? (entries.length === 1 && entries[0].prefix === '' ? entries[0] : undefined);
-            return hit ? byId.get(hit.id) : undefined;
-        },
-        childModel: (familyId, provider, capability) => {
-            const s = byId.get(familyId);
-            const prefix = s?.transports[provider];
-            return s && prefix !== undefined ? `${prefix}${s.childModels[capability]}` : undefined;
+        resolveSlot: (familyId, capability, parentModel, models) => {
+            const slot = byId.get(familyId)?.childModels[capability]?.toLowerCase();
+            if (!slot)
+                return undefined;
+            const hits = models.filter(m => bare(m).toLowerCase() === slot && prefixOf(m) === prefixOf(parentModel));
+            return hits.length === 1 ? hits[0] : undefined;
         },
         effortStart: (model) => {
             const name = bare(model);
@@ -73,9 +68,7 @@ export function createRegistry(input) {
                     return s.effortStarts[name];
             return undefined;
         },
-        hasProvider: (provider) => childPrefixes.has(provider),
         get: (familyId) => byId.get(familyId),
-        providers: () => [...childPrefixes.keys()],
         ids: () => strategies.map(s => s.id),
         labels: () => strategies.map(s => s.label),
     });

package/lib/strategies/types.d.ts

@@ -6,9 +6,8 @@ export interface FamilyStrategy {
     readonly label: string;
     /** Main-model support: matched case-insensitively against the id after its last `/`. */
     readonly modelPrefixes: readonly string[];
-    /** Transport provider → model-id prefix for this family's child models on that transport. */
-    readonly transports: Readonly<Record<string, string>>;
     /** Exact bare model id → recommended starting effort. */
     readonly effortStarts: Readonly<Record<string, StartEffort>>;
+    /** Bare child model names; the provider's live catalog supplies the full id. */
     readonly childModels: Readonly<Record<Capability, string>>;
 }

package/lib/subagent-tool.d.ts

@@ -9,6 +9,18 @@ interface SessionLike {
             origin?: string;
             parentSession?: string;
         };
+        requestHeader?: () => {
+            config?: {
+                provider?: string;
+                model?: string;
+                reasoningEffort?: string;
+            };
+        } | undefined;
+    };
+    options?: {
+        provider?: string;
+        model?: string;
+        reasoningEffort?: string;
     };
 }
 export interface ToolDeps {
@@ -18,7 +30,7 @@ export interface ToolDeps {
     };
     state: RoutingState;
     readSettings: () => Settings;
-    catalog: () => RoutingCatalog | Promise<RoutingCatalog>;
+    catalog: (provider?: string) => RoutingCatalog | Promise<RoutingCatalog>;
     registry?: Registry;
 }
 /** Preview only: the same Jev judgment AUTO uses, while the root session is AUTO. Writes no state. */

package/lib/subagent-tool.js

@@ -1,6 +1,6 @@
 import { defineTool } from '@deepseek-ai/dsh-tools';
 import { buildState } from './context.js';
-import { choosePolicyRoute, modelFamily } from './routing.js';
+import { chooseChildRoute } from './routing.js';
 import { registry as builtin } from './strategies/index.js';
 /** The ordinary session a caller belongs to; undefined when any link is no longer live (treated as MANUAL). */
 function rootOf(caller, agents) {
@@ -19,15 +19,14 @@ export function routeSubagentTool(jev, deps) {
     const registry = deps.registry ?? builtin;
     return defineTool({
         name: 'route_subagent',
-        description: 'Optional preview of the AUTO sub-agent route: returns a recommendation only, never an applied route. Automatic routing happens when the official fresh creation tool creates the exact child, before its first request; use that tool directly and do not turn this recommendation into an explicit user constraint. Fork is unsupported. Sends the task text (redacted, up to 8000 characters) to the decision service chosen in settings only while the main session is AUTO; otherwise returns routed=false: delegate with the official defaults. If the user or lead already chose the model or effort, pass it: only the missing dimension is judged. On error: pause delegation and ask the user; never guess or switch models.',
+        description: 'Optional preview of the AUTO sub-agent route: returns a recommendation only, never an applied route. Automatic routing happens when the official fresh creation tool creates the exact child, before its first request; use that tool directly and do not turn this recommendation into an explicit user constraint. Fork copies the parent and is not routed. Dispatch does not require calling this first. Sends the task text (redacted, up to 8000 characters) to the decision service chosen in settings only while the main session is AUTO; otherwise returns routed=false: delegate with the official defaults. If the user or lead already chose the model or effort, pass it: only the missing dimension is judged. status fallback: delegate with official defaults and tell the user why; needs-context: add goal and scope first; on error (including cancellation): pause delegation and ask the user; never guess or switch models.',
         timeoutMs: 10000,
         parameters: {
             task: { type: 'string', required: true, description: 'The task the sub-agent will do.' },
-            provider: { type: 'string', required: true, enum: registry.providers(), description: 'Exact transport provider of the sub-agent.' },
+            provider: { type: 'string', required: true, description: 'Exact provider of the sub-agent (any provider; normally the current session’s).' },
             model: { type: 'string', description: 'Sub-agent model already chosen by the user or lead; when given, only reasoning_effort is judged.' },
             reasoning_effort: { type: 'string', description: 'Effort already chosen by the user or lead; preserved and validated, never silently replaced.' },
-            family: { type: 'string', enum: registry.ids(), description: 'Model family for an automatic model on a transport shared by several families; required there when no model is supplied.' },
-            path: { type: 'string', enum: ['ordinary', 'fork', 'teammate'], description: 'Creation path; fork is unsupported.' },
+            path: { type: 'string', enum: ['ordinary', 'fork', 'teammate'], description: 'Creation path; fork is not routed.' },
         },
         output: {
             schema: {
@@ -46,8 +45,10 @@ export function routeSubagentTool(jev, deps) {
             },
             render: (_args, v) => [{ type: 'text', text: v.status === 'recommended'
                         ? `Recommended only (not applied): ${v.provider}/${v.model}/${v.reasoning_effort}. Use the official creation tool; AUTO judges and binds the exact child before its first request. Do not copy this recommendation as a new explicit user constraint. Query the child routing status for applied evidence.`
-                        : v.status ? `${v.status}: ${v.reason}. 暂停委派并询问用户；不将推荐冒充实际应用。`
-                            : MANUAL_TEXT }],
+                        : v.status === 'fallback' ? `fallback: ${v.reason}. 按官方默认委派，并向用户简要说明原因。`
+                            : v.status === 'needs-context' ? `needs-context: ${v.reason}. 补充目标与范围后再派发。`
+                                : v.status ? `${v.status}: ${v.reason}. fork 与父会话保持一致，AUTO 不路由。`
+                                    : MANUAL_TEXT }],
         },
         execute: async (args, exec) => {
             const root = rootOf(exec.agent, deps.agents);
@@ -55,23 +56,25 @@ export function routeSubagentTool(jev, deps) {
             if (!root || deps.state.read(root.id).mode !== 'AUTO')
                 return { routed: false, reason: 'manual' };
             if (args.path === 'fork')
-                return { routed: false, status: 'unsupported', reason: 'fork 的真实历史兼容尚未验证；请改用 fresh' };
+                return { routed: false, status: 'unsupported', reason: 'fork' };
+            if (!args.provider)
+                throw new Error('provider 为空；暂停委派并询问用户');
             const explicit = { ...(args.model ? { model: args.model } : {}), ...(args.reasoning_effort ? { reasoningEffort: args.reasoning_effort } : {}) };
             const result = explicit.model && explicit.reasoningEffort ? { kind: 'ok', depth: 'baseline', capability: 'bounded' }
                 : await jev.judgePolicy(buildState({ text: args.task }), exec.signal, 'child', explicit.model ? 'depth' : explicit.reasoningEffort ? 'capability' : 'both');
-            if (result.kind !== 'ok')
-                throw new Error('Jev 判断失败或已取消；暂停委派并询问用户');
+            if (result.kind === 'cancelled' || exec.signal.aborted)
+                throw new Error('子任务判断已取消；暂停委派并询问用户');
+            if (result.kind === 'failed')
+                return { routed: false, status: 'fallback', reason: `jev-${result.category}` };
             if (result.capability === 'insufficient_context')
                 return { routed: false, status: 'needs-context', reason: '请补充任务目标与范围' };
-            let route;
-            try {
-                route = choosePolicyRoute(args.provider, result.capability ?? 'bounded', result.depth, await deps.catalog(), deps.readSettings().effortCap, explicit, args.family ?? (args.model ? modelFamily(args.provider, args.model, registry) : undefined), registry);
-            }
-            catch (error) {
-                // No usable route: never substitute another model or effort.
-                const reason = error instanceof Error ? error.message : String(error);
-                throw new Error(reason.includes('暂停委派并询问用户') ? reason : `${reason}；暂停委派并询问用户`);
-            }
+            const caller = exec.agent;
+            const config = caller?.session.requestHeader?.()?.config;
+            const parent = { model: config?.model ?? caller?.options?.model, reasoningEffort: config?.reasoningEffort ?? caller?.options?.reasoningEffort };
+            const chosen = chooseChildRoute({ provider: args.provider, parent, explicit, capability: result.capability ?? 'bounded', depth: result.depth, catalog: await deps.catalog(args.provider), cap: deps.readSettings().effortCap }, registry);
+            if ('fallback' in chosen)
+                return { routed: false, status: 'fallback', reason: chosen.fallback };
+            const route = chosen.route;
             return { status: 'recommended', ...(result.capability ? { capability: result.capability } : {}), depth: result.depth, provider: route.provider, model: route.model, reasoning_effort: route.reasoningEffort };
         },
     });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-auto-model-routing",
-  "version": "0.5.2",
+  "version": "0.5.3",
   "description": "DeepSeek Harness plugin: independent Jev capability and effort decisions, enforced fresh-child routes, decision visibility and allocation feedback",
   "license": "MIT",
   "author": "prgrmrwy",

package/screenshots.json

@@ -1,4 +1,4 @@
 [
-  "docs/auto-routing.gif",
-  "docs/settings.gif"
+  "docs/auto-routing.png",
+  "docs/settings.png"
 ]

package/skills/subagent-model-routing/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: subagent-model-routing
-description: 创建或复用子智能体前使用：通过官方 fresh 创建工具委派，照实传递用户或 lead 指定的模型与 effort；可用 route_subagent 预览 AUTO 的子任务路由，失败时暂停委派并询问用户。
+description: 创建或复用子智能体前使用：通过官方 fresh 创建工具委派，照实传递用户或 lead 指定的模型与 effort；AUTO 在创建时自行选配，route_subagent 只是可选预览。
 ---
 
 # 子会话模型选择
@@ -11,19 +11,19 @@ AUTO 的子任务路由由插件在**官方 fresh 创建工具**创建的精确
 
 1. **使用官方 fresh 创建工具**（`subagent` 或 fresh `spawn_teammate`），给出清楚的目标与范围。目标或范围不足时，插件会返回 needs-context，请补充描述后重新创建。
 2. **显式指定的值照实传递**：用户或 lead 指定了模型或 effort 时，原样传给官方工具。只指定一个维度时，插件只判断另一个；两者都指定时不调用 Jev，只做校验。
-3. **`route_subagent` 只是预览**：它返回的 `status: recommended` 不等于已应用。不要把推荐结果当成用户的显式约束再传给官方工具；让插件在创建时自行选配。
+3. **`route_subagent` 只是可选预览**：派发不需要先预览，路由只在创建时判断一次。它返回的 `status: recommended` 不等于已应用；不要把推荐结果当成显式参数传给官方工具，让插件在创建时自行选配。
 4. **主会话为 MANUAL**：`route_subagent` 返回 `routed: false`。此时按官方默认委派，只传用户或 lead 指定的值，不传其它 provider/model/reasoning_effort，也不猜档位。
 5. **标注**：在 `description` 末尾以 `[model·effort]` 标注实际使用的配置，例如 `检查鉴权边界 [<model>·<effort>]`；不确定时先查第 7 条的应用证据。
-6. **fork 不支持**：`route_subagent` 对 fork 返回 unsupported，创建时插件也会拒绝。应暂停并改用 fresh 创建；不要擅自把 fork 换成 fresh 而不说明。
+6. **fork 与父会话保持一致**：AUTO 不路由 fork，按 DSH 原生行为继承父会话配置。需要按任务选配时改用 fresh。
 7. **应用证据**：通过 `childRouting` 状态接口查看对应子会话的 recommended / applied / unsupported / needs-context / failed。applied 来自实际请求头，而不是工具推荐；未绑定的创建路径不算已路由。
 
 ## 失败
 
-8. 工具或判断失败（余额不足、凭据无效、限流、地区受限、超时、目录或允许列表中没有可用路由等）：**暂停委派并询问用户**，把错误原文告诉用户。不得猜测档位、不得换用其它模型、不得改由主会话自己完成，也不自行重试或升级。工具被取消时，按用户的取消意图停止。
+8. 若调用了预览：返回 `status: fallback`（目录或允许列表中没有可用路由、判断服务失败等）时，按官方默认委派并向用户简要说明原因；返回 `needs-context` 时补充目标与范围后再派发；返回错误（含判断被取消）时**暂停委派并询问用户**，把错误原文告诉用户，不得猜测档位、换用其它模型、改由主会话自己完成或自行重试。创建时路由不可用会自动退化为 DSH 默认行为，并在主会话面板中告警。
 9. 工具不存在（插件未启用）：告知用户“子会话 Jev 选模未启用”，然后按官方默认委派，只传用户或 lead 指定的值。
 
 ## 复用
 
 10. 向已有子会话发送新任务前，先比较它的 `[model·effort]` 标注与新任务的需求。需要更高投入、不同模型家族，或无法确认原配置时，**新建**子会话。已创建的子会话收到后续消息时不会重新选模；创建后不动态修改其模型或 effort。
 
-此 skill 是使用指引，不能强制 Agent 每次委派前都执行某个工具。与环境级指令“委派前先调用 `route_subagent`”相容：MANUAL 下该调用返回 `routed: false`，按第 4 条处理即可。
+此 skill 是使用指引，不能强制 Agent 每次委派前都执行某个工具。与环境级指令「子会话派发」一致：直接用官方 fresh 工具派发，预览可选。