omp的“dsh-router-standard”

dsh插件原仓库: https://github.com/yjh051108/dsh-router-standard

dsh-router-standard的omp移植

就是这几天站里讨论那个能让思考内容大概率roll出we的

让sol花了一个早上写的, 跑了几次svg测试。

须新会话，中途切换无效，不保证一定有效喵。

效果

创建一个HTML，内容是SVG绘制一个鹈鹕骑自行车的2D动画，放到当前目录，你不需要任何测试

v4 flash:

v4 pro第一次:

v4 pro第二次:

拓展脚本 放入~/.omp/agent/extensions/<name>.ts```
import type { ExtensionAPI, ExtensionContext } from "@oh-my-pi/pi-coding-agent";

type RouterPhase = "anchored" | "promoted";
type FlashBand = "spec" | "react" | "weak";

type RouterState = {
version: 1;
phase: RouterPhase;
model: string;
fullTools: string[];
flashBand?: FlashBand;
};

const STATE_TYPE = "io.github.soeur.dsh-router-spec.omp.v1";
const PRO_MODEL_ID = "deepseek-v4-pro";
const FLASH_MODEL_ID = "deepseek-v4-flash";
const PRO_SYSTEM_PROMPT = ["You are a helpful software engineer assistant."];
const PRO_FIRST_TURN_TOOLS = ["read"];
const FLASH_FIRST_TURN_TOOLS: Readonly<Record<FlashBand, readonly string[]>> = {
spec: ["read", "edit", "glob", "grep"],
react: ["read", "write", "edit"],
weak: ["read", "write", "edit"],
};

const FLASH_SPEC_PERSONA =
"You are a helpful software engineer assistant.\n" +
"Reason in the first-person plural planning register. Keep that register after every tool result: continue with " +
"'We found...', 'We need...', or 'We should...'; do not switch to 'I', 'Let me', or impersonal narration.";
const FLASH_REACT_PERSONA =
"You are a hands-on software engineer who delivers working output fast.\n" +
"Work directly: write or edit code, then verify it by reading and running. " +
"Keep the loop tight — produce, verify, fix — and do not build test " +
"harnesses, scaffolding, or ceremony the user did not ask for. " +
"Finish with a usable deliverable and a short summary.\n" +
"Think deeply first, then produce.";
const FLASH_WEAK_PERSONA =
"You are a helpful assistant.\n" +
"Before acting, decide the task type (build or fix) and adopt the matching " +
"style: build → hands-on production; fix → inspect-and-plan.\n" +
"Before acting, briefly review what you have already done in this session and continue from where you left off; " +
"do not repeat completed steps. Do not run environment checks (echo, whoami, uname, node --version, date) or " +
"exhaustive grep/glob scans.\n" +
"Think deeply first, then produce.";
const FLASH_GUIDE_WEAK =
"Router: classify this task (build or fix) now, then adopt the matching style — build: direct production; " +
"fix: inspect-first. Think deeply first, then commit and act.";
const FLASH_GUIDE_DEEP =
"Router: classify this task (build or fix) now, then adopt the matching style — build: direct production; " +
"fix: inspect-first. Think deeply about the architecture, edge cases, and integration points. Do not spend " +
"reasoning on the environment or tooling. Produce when your information is complete. End each reasoning block " +
"with a decision or an information need.";

const REACT_TASK_RE =
/(开发|创建|写一个|生成|从零|做一个|游戏|网页|网站|构建|新项目|搭建|实现|做出|上线|落地|脚本|工具|应用|build|create|develop|generate|implement|make a|new project)/gi;
const SPEC_TASK_RE =
/(修复|修一下|调试|重构|维护|排查|报错|出错|崩溃|优化|审查|review|fix|debug|refactor|maintain|repair|broken|break|为什么|异常|故障|迁移|升级|兼容)/gi;
const COMPLEX_TASK_RE =
/(重构|架构|全面|详细|设计|系统|优化|分析|survey|overview|architecture|refactor|comprehensive|detailed|design|system|optimize|analyze)/i;

type LeanToolSchema = {
description: string;
parameters: Record<string, unknown>;
};

const LEAN_TOOL_SCHEMAS: Readonly<Record<string, LeanToolSchema>> = {
bash: {
description: "Run a command in a persistent shell.",
parameters: {
type: "object",
properties: { command: { type: "string" } },
required: ["command"],
},
},
pwsh: {
description: "Run a command in a persistent shell.",
parameters: {
type: "object",
properties: { command: { type: "string" } },
required: ["command"],
},
},
read: {
description: "Read a text file.",
parameters: {
type: "object",
properties: { path: { type: "string" } },
required: ["path"],
},
},
};

function rewriteFirstTurnToolSchemas(payload: unknown): unknown {
if (typeof payload !== "object" || payload === null) return payload;
const body = payload as Record<string, unknown>;
if (!Array.isArray(body.tools)) return payload;

let changed = false;
const tools = body.tools.map((tool: unknown) => {
if (typeof tool !== "object" || tool === null) return tool;
const entry = tool as Record<string, unknown>;
const providerFunction = entry.function;

if (typeof providerFunction === "object" && providerFunction !== null) {
const name = (providerFunction as Record<string, unknown>).name;
const schema = typeof name === "string" ? LEAN_TOOL_SCHEMAS[name] : undefined;
if (!schema) return tool;
changed = true;
return {
type: "function",
function: { name, description: schema.description, parameters: schema.parameters },
};
}

const name = entry.name;
const schema = typeof name === "string" ? LEAN_TOOL_SCHEMAS[name] : undefined;
if (!schema) return tool;
changed = true;
return { name, description: schema.description, input_schema: schema.parameters };
});

return changed ? { ...body, tools } : payload;
}
function classifyFlashTask(text: string): FlashBand {
const react = text.match(REACT_TASK_RE)?.length ?? 0;
const spec = text.match(SPEC_TASK_RE)?.length ?? 0;
if (spec > 0) return "spec";
if (react > 0) return "react";
return "weak";
}

function flashSystemPrompt(base: string[], band: FlashBand): string[] {
if (band === "spec") return [FLASH_SPEC_PERSONA, ...base];
if (band === "react") return [FLASH_REACT_PERSONA, ...base];
return [FLASH_WEAK_PERSONA, ...base];
}

function flashGuidance(band: FlashBand, task: string): string {
if (band === "spec") {
return "Router: this is a FIX task. Inspect first and reason deeply before repairing. " +
"Start your reasoning with the exact sentence: 'We need to inspect the code first.' " +
"Keep using the 'We' planning register in later reasoning blocks after tool results.";
}
if (band === "react") {
return "Router: this is a BUILD task. Use hands-on production, verify the result, and converge. " +
"Think deeply first, then commit and act.";
}
return task.length > 120 || COMPLEX_TASK_RE.test(task) ? FLASH_GUIDE_DEEP : FLASH_GUIDE_WEAK;
}

export default function dshRouterSpec(pi: ExtensionAPI): void {
let baselineTools: string[] = [];
let state: RouterState | undefined;
let changingTools = false;

pi.setLabel("DSH Router Spec");

function currentModel(ctx: ExtensionContext) {
return ctx.model ?? ctx.models.current();
}

function currentModelKey(ctx: ExtensionContext): string {
const model = currentModel(ctx);
return model ? ${model.provider}/${model.id} : "未选择";
}

function currentModelId(ctx: ExtensionContext): string | undefined {
return currentModel(ctx)?.id.toLowerCase().split("/").at(-1);
}

function isProModel(ctx: ExtensionContext): boolean {
return currentModelId(ctx) === PRO_MODEL_ID;
}

function isFlashModel(ctx: ExtensionContext): boolean {
return currentModelId(ctx) === FLASH_MODEL_ID;
}

function isTargetModel(ctx: ExtensionContext): boolean {
return isProModel(ctx) || isFlashModel(ctx);
}

function availableTools(toolNames: string[]): string[] {
const available = new Set(pi.getAllTools().map((tool) => tool.name));
return [...new Set(toolNames)].filter((name) => available.has(name));
}

function firstTurnTools(fullTools: string[], ctx: ExtensionContext): string[] {
const enabled = new Set(fullTools);
const tools: string[] = [];
const shell = ["bash", "pwsh"].find((name) => enabled.has(name));
if (shell) tools.push(shell);
const core = isFlashModel(ctx)
? FLASH_FIRST_TURN_TOOLS[state?.flashBand ?? "weak"]
: PRO_FIRST_TURN_TOOLS;
for (const name of core) {
if (enabled.has(name)) tools.push(name);
}
return tools;
}

async function applyTools(toolNames: string[]) {
changingTools = true;
try {
await pi.setActiveTools(availableTools(toolNames));
} finally {
changingTools = false;
}
}

function latestState(ctx: ExtensionContext): RouterState | undefined {
let latest: RouterState | undefined;
for (const entry of ctx.sessionManager.getBranch()) {
if (entry.type === "custom" && entry.customType === STATE_TYPE) {
latest = entry.data as RouterState;
}
}
return latest;
}

function hasAssistantHistory(ctx: ExtensionContext): boolean {
return ctx.sessionManager
.getBranch()
.some((entry) => entry.type === "message" && entry.message.role === "assistant");
}

function persistState() {
if (state) pi.appendEntry<RouterState>(STATE_TYPE, state);
}

async function restoreSession(ctx: ExtensionContext) {
state = latestState(ctx);
if (!state) {
await applyTools(baselineTools);
return;
}

if (state.phase === "anchored" && isTargetModel(ctx)) {
await applyTools(firstTurnTools(state.fullTools, ctx));
return;
}

await applyTools(state.fullTools);
}

async function promote(ctx: ExtensionContext, reason: "tool_call" | "turn_end") {
if (state?.phase !== "anchored" || changingTools || !isTargetModel(ctx)) return;

await applyTools(state.fullTools);
state = { ...state, phase: "promoted" };
persistState();
pi.logger.debug(dsh-router-spec: promoted after ${reason}, {
model: state.model,
toolCount: state.fullTools.length,
});
}

pi.on("session_start", async (_event, ctx) => {
baselineTools = pi.getActiveTools();
await restoreSession(ctx);
});

pi.on("session_switch", async (_event, ctx) => {
await restoreSession(ctx);
});

pi.on("session_branch", async (_event, ctx) => {
await restoreSession(ctx);
});

pi.on("session_tree", async (_event, ctx) => {
await restoreSession(ctx);
});

pi.on("before_agent_start", async (event, ctx) => {
if (!isTargetModel(ctx)) {
if (state?.phase === "anchored") await applyTools(state.fullTools);
return;
}

if (state?.phase === "promoted" && isProModel(ctx)) return;

if (!state) {
if (hasAssistantHistory(ctx)) return;

const fullTools = pi.getActiveTools();
state = {
version: 1,
phase: "anchored",
model: currentModelKey(ctx),
fullTools,
flashBand: isFlashModel(ctx) ? classifyFlashTask(event.prompt) : undefined,
};
persistState();
pi.logger.debug("dsh-router-spec: anchored", {
model: state.model,
band: state.flashBand ?? "pro-we",
tools: firstTurnTools(fullTools, ctx),
});
if (ctx.hasUI) {
const route = state.flashBand ? Flash ${state.flashBand} : "Pro We";
ctx.ui.notify(DSH Router Spec 已锚定：${route}, "info");
}
} else if (isFlashModel(ctx) && !state.flashBand) {
state = { ...state, flashBand: classifyFlashTask(event.prompt) };
persistState();
}

if (isFlashModel(ctx)) {
if (state.phase === "anchored") {
await applyTools(firstTurnTools(state.fullTools, ctx));
}
const band = state.flashBand ?? "weak";
pi.logger.debug("dsh-router-spec: Flash base prompt ready", {
parts: event.systemPrompt.length,
chars: event.systemPrompt.reduce((total, part) => total + part.length, 0),
});
return {
systemPrompt: flashSystemPrompt(event.systemPrompt, band),
message: {
customType: "dsh-router-guidance",
content: flashGuidance(band, event.prompt),
display: false,
attribution: "user",
},
};
}

await applyTools(firstTurnTools(state.fullTools, ctx));
return { systemPrompt: PRO_SYSTEM_PROMPT };
});

pi.on("before_provider_request", async (event, ctx) => {
if (state?.phase !== "anchored" || !isProModel(ctx)) return;
const payload = rewriteFirstTurnToolSchemas(event.payload);
pi.logger.debug("dsh-router-spec: injected Pro lean tool schemas", {
model: currentModelKey(ctx),
tools: firstTurnTools(state.fullTools, ctx),
});
return payload;
});

pi.on("tool_call", async (event, ctx) => {
if (state?.phase !== "anchored" || !isTargetModel(ctx)) return;

let revisedInput: Record<string, unknown> | undefined;
if (isProModel(ctx)) {
const input = event.input as Record<string, unknown>;
const intent = typeof input.i === "string" ? input.i : undefined;
if (event.toolName === "bash" || event.toolName === "pwsh") {
revisedInput = { ...input, i: intent ?? "Executing anchored command" };
} else if (event.toolName === "read") {
revisedInput = { ...input, i: intent ?? "Reading anchored file" };
}
}

await promote(ctx, "tool_call");
return revisedInput ? { input: revisedInput } : undefined;
});

pi.on("turn_end", async (_event, ctx) => {
await promote(ctx, "turn_end");
});

pi.registerCommand("dsh-router-status", {
description: "显示 DeepSeek V4 Pro/Flash 的 DSH spec 轨迹路由状态",
handler: async (_args, ctx) => {
state = latestState(ctx) ?? state;
const ready = isTargetModel(ctx) && !state && !hasAssistantHistory(ctx);
const phase = state?.phase ?? (ready ? "ready" : "inactive");
const fullTools = state?.fullTools ?? baselineTools;
ctx.ui.notify(
[
模型：${currentModelKey(ctx)},
状态：${phase},
路由：${state?.flashBand ?? (isProModel(ctx) ? "pro-we" : "未分类")},
首轮工具：${firstTurnTools(fullTools, ctx).join(", ") || "无"},
].join("\n"),
isTargetModel(ctx) ? "info" : "warning",
);
},
});
}