opencode-model-router 1.0.2 → 1.0.4

package/README.md

@@ -16,6 +16,16 @@ The agent automatically delegates via the Task tool when it recognizes the task
 
 This applies both to plan-driven execution and direct ad-hoc requests. For every new user message, the orchestrator performs an intent gate, splits multi-task requests into atomic units, and routes each unit to `@fast`, `@medium`, or `@heavy`.
 
+### Token overhead disclaimer
+
+The injected protocol is compact, but it still adds tokens on every iteration.
+
+- Estimated average injection: ~208 tokens per iteration
+- Preset breakdown (default `tiers.json`): `anthropic` ~209, `openai` ~206
+- Estimation method: `prompt_characters / 4` (rough heuristic)
+
+Real token usage varies by tokenizer/model and any custom changes you make to `tiers.json`.
+
 ## Installation
 
 ### Option A: npm package (recommended)
@@ -25,7 +35,7 @@ Add the plugin package in your `opencode.json`:
 ```json
 {
   "plugin": [
-    "opencode-model-router@1.0.0"
+    "opencode-model-router@latest"
   ]
 }
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-model-router",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "OpenCode plugin that routes tasks to tiered subagents (fast/medium/heavy) based on complexity",
   "type": "module",
   "main": "./src/index.ts",

package/src/index.ts

@@ -98,62 +98,30 @@ function buildAgentOptions(tier: TierConfig): Record<string, unknown> {
 function buildDelegationProtocol(cfg: RouterConfig): string {
   const tiers = getActiveTiers(cfg);
 
-  const tierRows = Object.entries(tiers)
+  const tierSummary = Object.entries(tiers)
     .map(([name, t]) => {
       const shortModel = t.model.split("/").pop() ?? t.model;
-      const thinkingInfo = t.variant ? ` (${t.variant})` : "";
-      return `| @${name} | \`${shortModel}\`${thinkingInfo} | ${t.description} |`;
+      const variant = t.variant ? ` (${t.variant})` : "";
+      return `@${name}=${shortModel}${variant}`;
     })
-    .join("\n");
-
-  const whenToUse = Object.entries(tiers)
-    .map(([name, t]) => `- **@${name}**: ${t.whenToUse.join(", ")}`)
-    .join("\n");
-
-  const rules = cfg.rules.map((r, i) => `${i + 1}. ${r}`).join("\n");
-
-  const directRoutingRules = [
-    "Run an Intent Gate for every new user message, even without a plan file.",
-    "If the message contains multiple asks, split it into atomic tasks before routing.",
-    "Route read-only exploration/search tasks to @fast.",
-    "Route implementation/edit/test/refactor tasks to @medium.",
-    "Route architecture/security/performance/complex debugging tasks to @heavy.",
-    "If a request mixes tiers, delegate each subtask to the right tier and then synthesize one final response.",
-    "If a task is trivial (single grep/read), execute directly instead of delegating.",
-    "When uncertain, default to the configured default tier unless user constraints clearly require another tier.",
-  ];
-
-  const directRoutingList = directRoutingRules
-    .map((rule, index) => `${index + 1}. ${rule}`)
-    .join("\n");
+    .join(" | ");
 
   return [
     "## Model Delegation Protocol",
+    `Preset: ${cfg.activePreset}. Tiers: ${tierSummary}.`,
     "",
-    `Active preset: **${cfg.activePreset}** (switch with \`/preset <name>\`)`,
-    `Available presets: ${Object.keys(cfg.presets).join(", ")}`,
-    "",
-    "| Agent | Model | Purpose |",
-    "|-------|-------|---------|",
-    tierRows,
-    "",
-    "### When to use each tier:",
-    whenToUse,
-    "",
-    "### Rules:",
-    rules,
-    "",
-    "### Direct Request Routing (No Plan Required):",
-    "These rules also apply to ad-hoc user requests, not only PLAN.md execution.",
-    directRoutingList,
-    "",
-    "### How to delegate:",
-    "Use the Task tool with the tier name as `subagent_type`:",
-    '- `Task(subagent_type="fast", prompt="Find all files importing AuthContext")`',
-    '- `Task(subagent_type="medium", prompt="Implement the UserService class per the spec")`',
-    '- `Task(subagent_type="heavy", prompt="Review this auth flow for security vulnerabilities")`',
+    "Apply to every user message (plan and ad-hoc):",
+    "1. Split multi-part requests into atomic tasks.",
+    "2. Respect explicit tier instructions and [tier:fast|medium|heavy] tags.",
+    "3. Route read-only search/exploration tasks to @fast.",
+    "4. Route implementation/edit/refactor/test/bugfix tasks to @medium.",
+    "5. Route architecture/security/performance/complex debugging to @heavy.",
+    "6. For mixed requests, delegate each subtask to the matching tier, then synthesize one final response.",
+    "7. For trivial single read/grep tasks, execute directly.",
+    `8. If uncertain, default to @${cfg.defaultTier}.`,
     "",
-    `Default tier when unspecified: **@${cfg.defaultTier}**`,
+    "Delegate with Task(subagent_type=\"fast|medium|heavy\", prompt=\"...\").",
+    "Keep orchestration and final synthesis in the primary agent.",
   ].join("\n");
 }