dsh-auto-model-routing 0.3.0 → 0.4.0

package/lib/settings-host.js

@@ -2,18 +2,20 @@ import { credentialRef } from '@deepseek-ai/dsh-credentials';
 import { launchEnvironmentOf } from '@deepseek-ai/dsh-launch-environment';
 import { DEFAULT_SETTINGS, SettingsValidationError } from './settings.js';
 import rubric from './rubric.json' with { type: 'json' };
-const keyRef = credentialRef('OPENROUTER_API_KEY');
+import { JevClient } from './jev.js';
+import { DECISION_SERVICES } from './decision-service.js';
+const keyRef = (provider = 'openrouter') => credentialRef(DECISION_SERVICES[provider].credential);
 /** Only the fixed credential reference and public catalog metadata cross this adapter. */
 export function settingsHost(ctx, store) {
     const environment = launchEnvironmentOf(ctx);
     const credentials = () => ctx.get('credentials');
-    const catalog = async () => {
-        const models = (await Promise.all(ctx.llm.listProviders().filter(p => p.id === 'claude' || p.id === 'codex').map(async (provider) => {
+    const catalog = async (includeMagpie = store.read().settings.policy === 'policy-v2') => {
+        const models = (await Promise.all(ctx.llm.listProviders().filter(p => p.id === 'claude' || p.id === 'codex' || (includeMagpie && p.id === 'dsh-magpie-connect')).map(async (provider) => {
             try {
                 return await Promise.all((await ctx.llm.listModels(provider.id)).map(async (model) => {
                     try {
                         const info = await ctx.llm.resolveModelInfo(provider.id, model.id);
-                        return { provider: provider.id, model: model.id, name: model.name, reasoningEfforts: (info.reasoning?.efforts ?? []).map(e => String(e.id)) };
+                        return { provider: provider.id, model: model.id, name: model.name, reasoningEfforts: (info.reasoning?.efforts ?? []).map(e => String(e.id)), ...(info.reasoning?.defaultEffort ? { defaultEffort: String(info.reasoning.defaultEffort) } : {}) };
                     }
                     catch {
                         return undefined;
@@ -29,23 +31,24 @@ export function settingsHost(ctx, store) {
         try {
             if (service) {
                 const current = service.current();
-                return { models, childAllowlist: { status: current.enabled ? 'enabled' : 'disabled', allowedModels: current.allowedModels.filter(r => r.provider === 'claude' || r.provider === 'codex') } };
+                return { models, childAllowlist: { status: current.enabled ? 'enabled' : 'disabled', allowedModels: current.allowedModels.filter(r => r.provider === 'claude' || r.provider === 'codex' || (includeMagpie && r.provider === 'dsh-magpie-connect')) } };
             }
         }
         catch { /* An unavailable policy must never broaden the allowed routes. */ }
         return { models, childAllowlist: { status: 'unavailable', allowedModels: [] } };
     };
-    const keyStatus = async () => {
+    const keyStatus = async (provider = store.read().settings.decisionService?.provider ?? 'openrouter') => {
+        const ref = keyRef(provider);
         const service = credentials();
         if (service) {
             try {
-                return { ...await service.describe(keyRef), available: true };
+                return { ...await service.describe(ref), available: true };
             }
             catch {
                 return { configured: false, writable: false, available: false };
             }
         }
-        return { configured: Boolean(environment.get('OPENROUTER_API_KEY')?.value), writable: false, available: false };
+        return { configured: Boolean(environment.get(ref)?.value), writable: false, available: false };
     };
     const read = async () => {
         const current = await catalog();
@@ -55,6 +58,11 @@ export function settingsHost(ctx, store) {
     const endpoint = async (operation, body) => {
         if (operation === 'settings')
             return Response.json(await read());
+        if (operation === 'testDecision') {
+            const client = new JevClient({ get: async (name) => credentials() ? credentials().resolve(credentialRef(name)) : environment.get(name) }, undefined, 4500, () => store.read().settings.decisionService);
+            const result = await client.judgePolicy('Public connection test: sort the numbers [3,1,2] in ascending order.', new AbortController().signal, 'child');
+            return Response.json(result);
+        }
         if (operation === 'saveSettings') {
             try {
                 store.save(body, await catalog());
@@ -69,19 +77,23 @@ export function settingsHost(ctx, store) {
         const service = credentials();
         if (!service)
             return Response.json({ error: '凭据服务不可用' }, { status: 503 });
-        if (typeof body !== 'object' || body === null || Array.isArray(body) || Object.keys(body).length !== 1 || !('value' in body))
+        if (typeof body !== 'object' || body === null || Array.isArray(body) || Object.keys(body).some(k => !['value', 'provider'].includes(k)) || !('value' in body))
             return Response.json({ error: '无效的凭据请求' }, { status: 400 });
+        const provider = 'provider' in body ? body.provider : 'openrouter';
+        if (typeof provider !== 'string' || !Object.hasOwn(DECISION_SERVICES, provider))
+            return Response.json({ error: '无效的服务商' }, { status: 400 });
+        const ref = keyRef(provider);
         const value = body.value;
         if (value !== null && (typeof value !== 'string' || !value || value.length > 512 || /\s/.test(value)))
             return Response.json({ error: 'API key 必须为不含空白的非空字符串，且不超过 512 字符' }, { status: 400 });
         try {
-            if (!(await service.describe(keyRef)).writable)
+            if (!(await service.describe(ref)).writable)
                 return Response.json({ error: '该 key 来自启动环境，需先从启动环境移除并重启才能在此管理' }, { status: 409 });
             if (value === null)
-                await service.unset(keyRef);
+                await service.unset(ref);
             else
-                await service.set(keyRef, value);
-            return Response.json({ key: await keyStatus() });
+                await service.set(ref, value);
+            return Response.json({ key: await keyStatus(provider) });
         }
         catch {
             return Response.json({ error: '无法更新 API key；请检查凭据服务与只读来源' }, { status: 500 });
@@ -91,7 +103,7 @@ export function settingsHost(ctx, store) {
         catalog, read, endpoint,
         credential: async (name) => {
             const service = credentials();
-            return service ? service.resolve(keyRef) : environment.get(name);
+            return service ? service.resolve(credentialRef(name)) : environment.get(name);
         },
     };
 }

package/lib/settings.js

@@ -2,11 +2,20 @@ import { chmodSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSy
 import { dirname } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { z } from 'zod';
+import { resolveDecisionService } from './decision-service.js';
 import { tiers } from './effort.js';
 import { AUTO_EFFORTS, DEFAULT_SETTINGS } from './settings-contract.js';
 import { isRecord, issue, MODEL_ID_PATTERN, validateChildRoute, validateFamilyMainEffort, validateMainRoute } from './settings-validation.js';
 export { DEFAULT_SETTINGS } from './settings-contract.js';
 const ordinary = {
+    decisionService: z.object({ provider: z.enum(['openrouter', 'typesafe', 'concentrate', 'custom']), model: z.string().regex(/^[A-Za-z0-9._:/~-]{1,128}$/).optional(), endpoint: z.string().max(2048).optional() }).strict().refine(value => { try {
+        resolveDecisionService(value);
+        return true;
+    }
+    catch {
+        return false;
+    } }, 'Invalid decision service'),
+    policy: z.enum(['legacy', 'policy-v2']),
     decisionToast: z.boolean(), defaultMode: z.enum(['MANUAL', 'AUTO']),
     effortCap: z.enum(AUTO_EFFORTS), jevTimeoutMs: z.number().int().min(1000).max(4500),
 };
@@ -183,8 +192,12 @@ export class SettingsStore {
             const parsed = schema.safeParse(raw[key]);
             if (parsed.success)
                 Object.assign(settings, { [key]: parsed.data });
-            else
+            else {
                 issues.push(...schemaIssues(parsed.error, key));
+                // A malformed explicit transport must never fall back to OpenRouter.
+                if (key === 'decisionService')
+                    Object.assign(settings, { decisionService: { provider: 'custom', endpoint: '' } });
+            }
         }
         for (const kind of ['mainEfforts', 'childRoutes']) {
             if (!Object.hasOwn(raw, kind))

package/lib/subagent-tool.js

@@ -5,6 +5,8 @@ import { DEFAULT_SETTINGS } from './settings-contract.js';
 import { validateChildRoute } from './settings-validation.js';
 import { CATEGORY_HINTS } from './jev.js';
 import { buildState } from './context.js';
+import { choosePolicyRoute, modelFamily } from './policy-v2.js';
+import { policyVersion } from './jev.js';
 /** The ordinary session a caller belongs to; undefined when any link is no longer live (treated as MANUAL). */
 function rootOf(caller, agents) {
     let current = caller;
@@ -21,12 +23,15 @@ const MANUAL_TEXT = '主会话为 MANUAL：不判档，按官方默认委派；
 export function routeSubagentTool(jev, deps) {
     return defineTool({
         name: 'route_subagent',
-        description: 'Call before every sub-agent delegation, whatever the task size. Picks provider/model/reasoning_effort with the Jev decision model; pass provider, model and reasoning_effort explicitly to the sub-agent tool, or the sub-agent inherits this session\'s effort. Sends the task text (redacted, up to 8000 characters) to OpenRouter/TypeSafe only while the main session is AUTO; otherwise returns routed=false: delegate with the official defaults. If the user or lead already chose the sub-agent model, pass it as model: only reasoning_effort is routed and the model is kept. On error: pause delegation and ask the user; never guess a tier.',
+        description: 'When policy-v2 is selected, this tool is an optional preview only: use the official fresh creation tool directly for exact-child automatic routing, do not turn preview output into explicit user constraints; fork is unsupported. Under the legacy policy: Call before every sub-agent delegation, whatever the task size. Picks provider/model/reasoning_effort with the Jev decision model; pass provider, model and reasoning_effort explicitly to the sub-agent tool, or the sub-agent inherits this session\'s effort. Sends the task text (redacted, up to 8000 characters) to OpenRouter/TypeSafe only while the main session is AUTO; otherwise returns routed=false: delegate with the official defaults. If the user or lead already chose the sub-agent model, pass it as model: only reasoning_effort is routed and the model is kept. On error: pause delegation and ask the user; never guess a tier.',
         timeoutMs: 5000,
         parameters: {
             task: { type: 'string', required: true, description: 'The task the sub-agent will do.' },
-            provider: { type: 'string', required: true, enum: ['claude', 'codex'], description: 'Provider family for the sub-agent.' },
+            provider: { type: 'string', required: true, enum: ['claude', 'codex', 'dsh-magpie-connect'], description: 'Exact transport provider. Magpie is available only under policy-v2.' },
             model: { type: 'string', description: 'Sub-agent model already chosen by the user or lead; when given, only reasoning_effort is routed.' },
+            reasoning_effort: { type: 'string', description: 'Explicit effort constraint for policy-v2; preserved and validated, never silently replaced.' },
+            family: { type: 'string', enum: ['claude', 'codex'], description: 'Magpie automatic capability family; required when no model is explicitly supplied.' },
+            path: { type: 'string', enum: ['ordinary', 'fork', 'teammate'], description: 'policy-v2 creation path; fork remains unsupported until real history compatibility is verified.' },
         },
         output: {
             schema: {
@@ -34,6 +39,10 @@ export function routeSubagentTool(jev, deps) {
                 additionalProperties: false,
                 properties: {
                     routed: { type: 'boolean' },
+                    status: { type: 'string' },
+                    policyVersion: { type: 'string' },
+                    capability: { type: 'string' },
+                    depth: { type: 'string' },
                     reason: { type: 'string' },
                     tier: { type: 'string' },
                     provider: { type: 'string' },
@@ -41,9 +50,12 @@ export function routeSubagentTool(jev, deps) {
                     reasoning_effort: { type: 'string' },
                 },
             },
-            render: (_args, v) => [{ type: 'text', text: v.routed === false
-                        ? MANUAL_TEXT
-                        : `Delegate with provider=${v.provider} model=${v.model} reasoning_effort=${v.reasoning_effort} (tier ${v.tier}); label the description [${v.model}·${v.reasoning_effort}].` }],
+            render: (_args, v) => [{ type: 'text', text: v.status ? (v.status === 'recommended'
+                        ? `policy-v2 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.`
+                        : `policy-v2 ${v.status}: ${v.reason}. 暂停委派并询问用户；不将推荐冒充实际应用。`)
+                        : v.routed === false
+                            ? MANUAL_TEXT
+                            : `Delegate with provider=${v.provider} model=${v.model} reasoning_effort=${v.reasoning_effort} (tier ${v.tier}); label the description [${v.model}·${v.reasoning_effort}].` }],
         },
         execute: async (args, exec) => {
             const caller = exec.agent;
@@ -51,6 +63,21 @@ export function routeSubagentTool(jev, deps) {
             // MANUAL (or disabled, or an unreachable root): no judgement and nothing leaves the machine.
             if (!root || deps.state.read(root.id).mode !== 'AUTO')
                 return { routed: false, reason: 'manual' };
+            if (deps.readSettings?.().policy === 'policy-v2') {
+                if (args.path === 'fork')
+                    return { routed: false, status: 'unsupported', policyVersion, reason: 'fork 真实历史兼容尚未验证；选择 fresh 或由用户关闭试验后继承' };
+                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('policy-v2 Jev 判断失败或取消；暂停委派并询问用户');
+                if (result.capability === 'insufficient_context')
+                    return { routed: false, status: 'needs-context', policyVersion, reason: '请补充任务目标与范围' };
+                const 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) : undefined));
+                return { status: 'recommended', policyVersion, ...(result.capability ? { capability: result.capability } : {}), depth: result.depth, provider: route.provider, model: route.model, reasoning_effort: route.reasoningEffort };
+            }
+            if (args.provider === 'dsh-magpie-connect')
+                throw new Error('Magpie 路由需显式选择 policy-v2；原策略不变');
             const result = await jev.judge(buildState({ text: args.task }), exec.signal);
             if (result.kind === 'cancelled')
                 throw new Error('route_subagent 已取消。');

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "dsh-auto-model-routing",
-  "version": "0.3.0",
-  "description": "DeepSeek Harness plugin: use Jev to adjust reasoning effort per turn without changing the selected model, with configurable subagent routing",
+  "version": "0.4.0",
+  "description": "DeepSeek Harness plugin: independent Jev capability and effort decisions, enforced fresh-child routes, decision visibility and allocation feedback",
   "license": "MIT",
   "author": "prgrmrwy",
   "repository": { "type": "git", "url": "git+https://github.com/prgrmrwy/dsh-auto-model-routing.git" },
@@ -99,7 +99,7 @@
     "@deepseek-ai/dsh-credentials": "^0.2.0-rc.2",
     "@deepseek-ai/dsh-llm": "^0.2.0-rc.2",
     "@deepseek-ai/dsh-session-projection": "^0.2.0-rc.2",
-    "react": "^19.0.0",
+    "react": "^18.3.1 || ^19.0.0",
     "@deepseek-ai/dsh-launch-environment": "^0.2.0-rc.2",
     "@deepseek-ai/dsh-skill-filesystem": "^0.2.0-rc.2",
     "@deepseek-ai/dsh-tools": "^0.2.0-rc.2"

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

@@ -7,6 +7,21 @@ description: 创建或复用子智能体前，调用 route_subagent（Jev 判档
 
 判档由插件工具 `route_subagent` 完成（与主会话 AUTO 共用同一个 Jev 判断），主 Agent 不自行估档。工具跟随所属主会话的模式：只有主会话为 AUTO 时才判档，并把脱敏后的任务文本发送给 OpenRouter/TypeSafe；主会话为 MANUAL 时不判档、不外发。
 
+## 默认 AUTO（优先于下方旧策略回滚规则）
+
+无需选择版本；未显式配置 legacy 回滚且根会话为 AUTO 时：Agent 仍决定拆解、派发和验收；AUTO 在官方创建工具的精确 child 身份上选配资源，主子问题不再相同。
+
+- Magpie 使用精确 provider `dsh-magpie-connect` 和完整带前缀 model ID，不改成本地 claude/codex；自动槽支持 Claude/GPT 家族，其他网关模型需显式模型与可验证 effort。当前本机测试仅走 Magpie，OpenRouter 只用于 Jev，不直接调用本地 Claude/codex。
+- 使用官方 fresh `subagent` / `spawn_teammate` 创建，提供清楚的目标和范围即可；不要为自动任务先调用推荐工具再把推荐伪装成用户显式约束。请求首次发送前 AUTO 会判断能力与投入、验证目录并应用。
+- 用户显式指定 model/effort 时照实传递；只指定一个维度仅判断另一个，两者指定则不调用 Jev。只指定 effort 也不能沿用下方“完全不判”的原策略规则。
+- `route_subagent` 在此分支仅做可选预览，`status: recommended` 不是 applied；fork 返回 unsupported，应暂停并改用 fresh，或让用户明确选择关闭试验后继承。不要擅自将 fork 改为 fresh。
+- 通过 `childRouting` 状态接口检查对应 sessionId 的 recommended/applied/unsupported/needs-context/failed；应用证据来自实际 request/header，不来自工具推荐。未绑定的创建路径不冒充已路由。
+- 已创建成员收到后续消息不重选；需要升级视作 Agent 明确发起的新建资源决策，说明原因并保留显式约束，不进行自治重试。
+- 验收时区分任务描述不足、信息缺失、推理投入不足、能力不足与基础设施故障；网络错误不是自动升级理由。
+- MANUAL 停止新决策，已创建实例保持初始路线；关闭试验回到原策略，不删除已绑定子会话的恢复记录。
+
+以下规则只适用于原策略。
+
 ## 创建
 
 1. 尊重用户或 lead 显式指定的模型与 effort：

package/lib/selection-projection.d.ts

@@ -1,8 +0,0 @@
-import type { Selection } from './state.js';
-import type { ProjectionDefinition } from '@deepseek-ai/dsh-session-projection';
-declare module '@deepseek-ai/dsh-session-projection/types' {
-    interface SessionProjectionStateMap {
-        autoRoutingSelection: Selection | null;
-    }
-}
-export declare const selectionProjection: ProjectionDefinition<'autoRoutingSelection'>;

package/lib/selection-projection.js

@@ -1,7 +0,0 @@
-import { z } from 'zod';
-export const selectionProjection = {
-    key: 'autoRoutingSelection', stateVersion: 1,
-    stateSchema: z.object({ provider: z.string(), model: z.string(), reasoningEffort: z.enum(['low', 'medium', 'high', 'xhigh', 'max']).optional() }).transform(value => ({ provider: value.provider, model: value.model, ...(value.reasoningEffort ? { reasoningEffort: value.reasoningEffort } : {}) })).nullable(),
-    init: () => null,
-    apply: (state, event) => event.type === 'model/selection' ? event.data : state,
-};