opencode-morphllm 0.0.5 → 0.0.7

package/.gitleaks.toml

@@ -0,0 +1,6 @@
+title = "Gitleaks Config"
+
+[[rules]]
+id = "morph-key"
+description = "Morph API Key"
+regex = "sk-[A-Za-z0-9_-]{48}"

package/.husky/pre-commit

@@ -1,4 +1,6 @@
 #!/usr/bin/env sh
 . "$(dirname -- "$0")/_/husky.sh"
 
-bunx lint-staged
+bunx lint-staged
+
+gitleaks protect --staged --config .gitleaks.toml --verbose || true

package/.prettierignore

@@ -0,0 +1 @@
+dist/

package/.prettierrc

@@ -5,4 +5,4 @@
   "printWidth": 80,
   "tabWidth": 2,
   "useTabs": false
-}
+}

package/README.md

@@ -1,5 +1,8 @@
 # MorphLLM OpenCode Plugin
 
+[![npm](https://img.shields.io/npm/v/opencode-morphllm?style=flat-square)](https://www.npmjs.com/package/opencode-morphllm)
+[![downloads](https://img.shields.io/npm/dt/opencode-morphllm?style=flat-square)](https://www.npmjs.com/package/opencode-morphllm)
+
 This is an OpenCode Plugin for [MorphLLM](https://morphllm.com/). This plugin just adds in `edit_file` and `warpgrep_codebase_search` from MorphLLM to your agent configs as well as the intelligent model router for choosing different models based on the difficulty of the prompt.
 
 Github: https://github.com/VitoLin/opencode-morphllm
@@ -22,11 +25,27 @@ Example configs:
 
 ```json
 {
-  "MORPH_API_KEY": "sk-I05oNc_g83uRY-T4iOE47vCWuqbkG_MOKNhbZqcmzU-aXuXQ",
+  "MORPH_API_KEY": "YOUR_API_KEY_HERE",
+  "MORPH_ROUTER_CONFIGS": {
+    "MORPH_MODEL_EASY": "github-copilot/gpt-5-mini",
+    "MORPH_MODEL_MEDIUM": "opencode/minimax-m2.1-free",
+    "MORPH_MODEL_HARD": "github-copilot/gemini-2.5-pro",
+    "MORPH_ROUTER_ENABLED": true,
+    "MORPH_ROUTER_PROMPT_CACHING_AWARE": true
+  }
+}
+```
+
+Legacy format (still supported):
+
+```json
+{
+  "MORPH_API_KEY": "YOUR_API_KEY_HERE",
   "MORPH_MODEL_EASY": "github-copilot/gpt-5-mini",
   "MORPH_MODEL_MEDIUM": "opencode/minimax-m2.1-free",
   "MORPH_MODEL_HARD": "github-copilot/gemini-2.5-pro",
-  "MORPH_ROUTER_ENABLED": true
+  "MORPH_ROUTER_ENABLED": true,
+  "MORPH_ROUTER_PROMPT_CACHING_AWARE": true
 }
 ```
 

package/bun.lock

@@ -10,6 +10,7 @@
       },
       "devDependencies": {
         "bun-types": "^1.3.6",
+        "coverage-badges-cli": "^2.2.0",
         "husky": "^8.0.3",
         "lint-staged": "^15.2.0",
         "prettier": "^3.2.5",
@@ -34,6 +35,12 @@
 
     "@standard-schema/spec": ["@standard-schema/spec@1.1.0", "", {}, "sha512-l2aFy5jALhniG5HgqrD6jXLi/rUWrKvqN/qJx6yoJsgKhblVd+iqqU4RCXavm/jPityDo5TCvKMnpjKnOriy0w=="],
 
+    "@types/fs-extra": ["@types/fs-extra@11.0.4", "", { "dependencies": { "@types/jsonfile": "*", "@types/node": "*" } }, "sha512-yTbItCNreRooED33qjunPthRcSjERP1r4MqCZc7wv0u2sUkzTFp45tgUfS5+r7FrZPdmCCNflLhVSP/o+SemsQ=="],
+
+    "@types/jsonfile": ["@types/jsonfile@6.1.4", "", { "dependencies": { "@types/node": "*" } }, "sha512-D5qGUYwjvnNNextdU59/+fI+spnwtTFmyQP0h+PfIOSkNfpU6AOICUOkm4i0OnSk+NyjdPJrxCDro0sJsWlRpQ=="],
+
+    "@types/minimist": ["@types/minimist@1.2.5", "", {}, "sha512-hov8bUuiLiyFPGyFPE1lwWhmzYbirOXQNNo40+y3zow8aFVTeyn3VWL0VFFfdNddA8S4Vf0Tc062rzyNr7Paag=="],
+
     "@types/node": ["@types/node@25.0.10", "", { "dependencies": { "undici-types": "~7.16.0" } }, "sha512-zWW5KPngR/yvakJgGOmZ5vTBemDoSqF3AcV/LrO5u5wTWyEAVVh+IT39G4gtyAkh3CtTZs8aX/yRM82OfzHJRg=="],
 
     "@types/node-fetch": ["@types/node-fetch@2.6.13", "", { "dependencies": { "@types/node": "*", "form-data": "^4.0.4" } }, "sha512-QGpRVpzSaUs30JBSGPjOg4Uveu384erbHBoT1zeONvyCfwQxIkUshLAOqN/k9EjGviPRmWTTe6aH2qySWKTVSw=="],
@@ -62,6 +69,8 @@
 
     "available-typed-arrays": ["available-typed-arrays@1.0.7", "", { "dependencies": { "possible-typed-array-names": "^1.0.0" } }, "sha512-wvUjBtSGN7+7SjNpq/9M2Tg350UZD3q62IFZLbRAR1bSMlCo1ZaeW+BJ+D090e4hIIZLBcTDWe4Mh4jvUDajzQ=="],
 
+    "badgen": ["badgen@3.2.3", "", {}, "sha512-svDuwkc63E/z0ky3drpUppB83s/nlgDciH9m+STwwQoWyq7yCgew1qEfJ+9axkKdNq7MskByptWUN9j1PGMwFA=="],
+
     "base64-js": ["base64-js@1.5.1", "", {}, "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA=="],
 
     "braces": ["braces@3.0.3", "", { "dependencies": { "fill-range": "^7.1.1" } }, "sha512-yQbXgO/OSZVD2IsiLlro+7Hf6Q18EJrKSEsdoMzKePKXct3gvD8oLcOQdIzGupr5Fj+EDe8gO/lxc1BzfMpxvA=="],
@@ -92,6 +101,8 @@
 
     "commander": ["commander@13.1.0", "", {}, "sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw=="],
 
+    "coverage-badges-cli": ["coverage-badges-cli@2.2.0", "", { "dependencies": { "@types/fs-extra": "~11.0.0", "@types/minimist": "~1.2.2", "badgen": "~3.2.3", "fs-extra": "~11.2.0", "lodash.get": "^4.4.2", "mini-svg-data-uri": "^1.4.4", "minimist": "~1.2.5" }, "bin": { "coverage-badges": "bin/cli", "coverage-badges-cli": "bin/cli" } }, "sha512-7E7TtxiybFkK5/FRkzt4WTNZkopEv+hra7I7k52fnOD0YBweCnmV4b0FCCEvnO8567e+xCEZ3AdbIfeVlkh+hg=="],
+
     "crc-32": ["crc-32@1.2.2", "", { "bin": { "crc32": "bin/crc32.njs" } }, "sha512-ROmzCKrTnOwybPcJApAA6WBWij23HVfGVNKqqrZpuyZOHqK2CwHSvpGuyt/UNNvaIjEd8X5IFGp4Mh+Ie1IHJQ=="],
 
     "cross-spawn": ["cross-spawn@7.0.6", "", { "dependencies": { "path-key": "^3.1.0", "shebang-command": "^2.0.0", "which": "^2.0.1" } }, "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA=="],
@@ -144,6 +155,8 @@
 
     "formdata-node": ["formdata-node@4.4.1", "", { "dependencies": { "node-domexception": "1.0.0", "web-streams-polyfill": "4.0.0-beta.3" } }, "sha512-0iirZp3uVDjVGt9p49aTaqjk84TrglENEDuqfdlZQ1roC9CWlPk6Avf8EEnZNcAqPonwkG35x4n3ww/1THYAeQ=="],
 
+    "fs-extra": ["fs-extra@11.2.0", "", { "dependencies": { "graceful-fs": "^4.2.0", "jsonfile": "^6.0.1", "universalify": "^2.0.0" } }, "sha512-PmDi3uwK5nFuXh7XDTlVnS17xJS7vW36is2+w3xcv8SVxiB4NyATf4ctkVY5bkSjX0Y4nbvZCq1/EjtEyr9ktw=="],
+
     "function-bind": ["function-bind@1.1.2", "", {}, "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA=="],
 
     "get-east-asian-width": ["get-east-asian-width@1.4.0", "", {}, "sha512-QZjmEOC+IT1uk6Rx0sX22V6uHWVwbdbxf1faPqJ1QhLdGgsRGCZoyaQBm/piRdJy/D2um6hM1UP7ZEeQ4EkP+Q=="],
@@ -156,6 +169,8 @@
 
     "gopd": ["gopd@1.2.0", "", {}, "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg=="],
 
+    "graceful-fs": ["graceful-fs@4.2.11", "", {}, "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ=="],
+
     "has-property-descriptors": ["has-property-descriptors@1.0.2", "", { "dependencies": { "es-define-property": "^1.0.0" } }, "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg=="],
 
     "has-symbols": ["has-symbols@1.1.0", "", {}, "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ=="],
@@ -196,12 +211,16 @@
 
     "json-schema": ["json-schema@0.4.0", "", {}, "sha512-es94M3nTIfsEPisRafak+HDLfHXnKBhV3vU5eqPcS3flIWqcxJWgXHXiey3YrpaNsanY5ei1VoYEbOzijuq9BA=="],
 
+    "jsonfile": ["jsonfile@6.2.0", "", { "dependencies": { "universalify": "^2.0.0" }, "optionalDependencies": { "graceful-fs": "^4.1.6" } }, "sha512-FGuPw30AdOIUTRMC2OMRtQV+jkVj2cfPqSeWXv1NEAJ1qZ5zb1X6z1mFhbfOB/iy3ssJCD+3KuZ8r8C3uVFlAg=="],
+
     "lilconfig": ["lilconfig@3.1.3", "", {}, "sha512-/vlFKAoH5Cgt3Ie+JLhRbwOsCQePABiU3tJ1egGvyQ+33R/vcwM2Zl2QR/LzjsBeItPt3oSVXapn+m4nQDvpzw=="],
 
     "lint-staged": ["lint-staged@15.5.2", "", { "dependencies": { "chalk": "^5.4.1", "commander": "^13.1.0", "debug": "^4.4.0", "execa": "^8.0.1", "lilconfig": "^3.1.3", "listr2": "^8.2.5", "micromatch": "^4.0.8", "pidtree": "^0.6.0", "string-argv": "^0.3.2", "yaml": "^2.7.0" }, "bin": { "lint-staged": "bin/lint-staged.js" } }, "sha512-YUSOLq9VeRNAo/CTaVmhGDKG+LBtA8KF1X4K5+ykMSwWST1vDxJRB2kv2COgLb1fvpCo+A/y9A0G0znNVmdx4w=="],
 
     "listr2": ["listr2@8.3.3", "", { "dependencies": { "cli-truncate": "^4.0.0", "colorette": "^2.0.20", "eventemitter3": "^5.0.1", "log-update": "^6.1.0", "rfdc": "^1.4.1", "wrap-ansi": "^9.0.0" } }, "sha512-LWzX2KsqcB1wqQ4AHgYb4RsDXauQiqhjLk+6hjbaeHG4zpjjVAB6wC/gz6X0l+Du1cN3pUB5ZlrvTbhGSNnUQQ=="],
 
+    "lodash.get": ["lodash.get@4.4.2", "", {}, "sha512-z+Uw/vLuy6gQe8cfaFWD7p0wVv8fJl3mbzXh33RS+0oW2wvUqiRXiQ69gLWSLpgB5/6sU+r6BlQR0MBILadqTQ=="],
+
     "log-update": ["log-update@6.1.0", "", { "dependencies": { "ansi-escapes": "^7.0.0", "cli-cursor": "^5.0.0", "slice-ansi": "^7.1.0", "strip-ansi": "^7.1.0", "wrap-ansi": "^9.0.0" } }, "sha512-9ie8ItPR6tjY5uYJh8K/Zrv/RMZ5VOlOWvtZdEHYSTFKZfIBPQa9tOAEeAWhd+AnIneLJ22w5fjOYtoutpWq5w=="],
 
     "math-intrinsics": ["math-intrinsics@1.1.0", "", {}, "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g=="],
@@ -220,6 +239,8 @@
 
     "mimic-response": ["mimic-response@3.1.0", "", {}, "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ=="],
 
+    "mini-svg-data-uri": ["mini-svg-data-uri@1.4.4", "", { "bin": { "mini-svg-data-uri": "cli.js" } }, "sha512-r9deDe9p5FJUPZAk3A59wGH7Ii9YrjjWw0jmw/liSbHl2CHiyXj6FcDXDu2K3TjVAXqiJdaw3xxwlZZr9E6nHg=="],
+
     "minimist": ["minimist@1.2.8", "", {}, "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA=="],
 
     "minimisted": ["minimisted@2.0.1", "", { "dependencies": { "minimist": "^1.2.5" } }, "sha512-1oPjfuLQa2caorJUM8HV8lGgWCc0qqAO1MNv/k05G4qslmsndV/5WdNZrqCiyqiz3wohia2Ij2B7w2Dr7/IyrA=="],
@@ -304,6 +325,8 @@
 
     "undici-types": ["undici-types@7.16.0", "", {}, "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw=="],
 
+    "universalify": ["universalify@2.0.1", "", {}, "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw=="],
+
     "web-streams-polyfill": ["web-streams-polyfill@4.0.0-beta.3", "", {}, "sha512-QW95TCTaHmsYfHDybGMwO5IJIM93I/6vTRk+daHTWFPhwh+C8Cg7j7XyKrwrj8Ib6vYXe0ocYNrmzY4xAAN6ug=="],
 
     "webidl-conversions": ["webidl-conversions@3.0.1", "", {}, "sha512-2JAn3z8AR6rjK8Sm8orRC0h/bcl/DqL7tRPdGZ4I1CjdF+EaMLmYxBHyXuKL849eucPFhvBoxMsflfOb8kxaeQ=="],

package/bunfig.toml

@@ -0,0 +1,4 @@
+[test]
+coverage = true
+coverageThreshold = 0.7
+coverageReporter = ["lcov"]

package/dist/index.js

@@ -1,17 +1,16 @@
-import { createBuiltinMcps } from './mcps';
-import { createModelRouterHook } from './router';
-import { MORPH_ROUTER_ENABLED } from './config';
+import { createBuiltinMcps } from './morph/mcps';
+import { createModelRouterHook } from './morph/router';
 const MorphOpenCodePlugin = async () => {
-  const builtinMcps = createBuiltinMcps();
-  const routerHook = MORPH_ROUTER_ENABLED ? createModelRouterHook() : {};
-  return {
-    config: async (currentConfig) => {
-      currentConfig.mcp = {
-        ...currentConfig.mcp,
-        ...builtinMcps,
-      };
-    },
-    ...routerHook,
-  };
+    const builtinMcps = createBuiltinMcps();
+    const routerHook = createModelRouterHook();
+    return {
+        config: async (currentConfig) => {
+            currentConfig.mcp = {
+                ...currentConfig.mcp,
+                ...builtinMcps,
+            };
+        },
+        ...routerHook,
+    };
 };
 export default MorphOpenCodePlugin;

package/dist/morph/mcps.js

@@ -0,0 +1,15 @@
+import { API_KEY } from '../shared/config';
+export function createBuiltinMcps() {
+    return {
+        morph_mcp: {
+            type: 'local',
+            command: ['npx', '-y', '@morphllm/morphmcp'],
+            environment: {
+                MORPH_API_KEY: API_KEY,
+                ENABLED_TOOLS: 'edit_file,warpgrep_codebase_search',
+            },
+            enabled: true,
+        },
+    };
+}
+export default createBuiltinMcps;

package/dist/morph/mcps.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/mcps.test.js

@@ -0,0 +1,39 @@
+import { describe, it, expect, vi } from 'bun:test';
+vi.mock('../shared/config', () => ({
+    API_KEY: 'test-api-key-123',
+}));
+import { createBuiltinMcps } from './mcps';
+describe('mcps.ts', () => {
+    describe('createBuiltinMcps', () => {
+        it('should create morph_mcp configuration', () => {
+            const mcps = createBuiltinMcps();
+            expect(mcps).toHaveProperty('morph_mcp');
+            expect(mcps.morph_mcp.type).toBe('local');
+            expect(mcps.morph_mcp.enabled).toBe(true);
+        });
+        it('should set correct command for morph_mcp', () => {
+            const mcps = createBuiltinMcps();
+            expect(mcps.morph_mcp.command).toEqual([
+                'npx',
+                '-y',
+                '@morphllm/morphmcp',
+            ]);
+        });
+        it('should set MORPH_API_KEY in environment', () => {
+            const mcps = createBuiltinMcps();
+            const env = mcps.morph_mcp.environment;
+            expect(env).toBeDefined();
+            expect(env?.MORPH_API_KEY).toBe('test-api-key-123');
+        });
+        it('should set ENABLED_TOOLS environment variable', () => {
+            const mcps = createBuiltinMcps();
+            const env = mcps.morph_mcp.environment;
+            expect(env).toBeDefined();
+            expect(env?.ENABLED_TOOLS).toBe('edit_file,warpgrep_codebase_search');
+        });
+        it('should only create morph_mcp key', () => {
+            const mcps = createBuiltinMcps();
+            expect(Object.keys(mcps)).toEqual(['morph_mcp']);
+        });
+    });
+});

package/dist/morph/router.d.ts

@@ -0,0 +1,22 @@
+import type { Part, UserMessage } from '@opencode-ai/sdk';
+import type { RouterInput, RawRouterResult } from '@morphllm/morphsdk';
+export declare function createModelRouterHook(): {
+    'chat.message': (input: {
+        sessionID: string;
+        agent?: string;
+        model?: {
+            providerID: string;
+            modelID: string;
+        };
+        messageID?: string;
+        variant?: string;
+        classify?: (args: RouterInput) => Promise<RawRouterResult>;
+    }, output: {
+        message: UserMessage;
+        parts: Part[];
+    }) => Promise<void>;
+};
+export declare function extractPromptText(parts: Array<{
+    type: string;
+    text?: string;
+}>): string;

package/dist/morph/router.js

@@ -0,0 +1,65 @@
+import { MorphClient } from '@morphllm/morphsdk';
+import { API_KEY, MORPH_MODEL_EASY, MORPH_MODEL_MEDIUM, MORPH_MODEL_HARD, MORPH_MODEL_DEFAULT, MORPH_ROUTER_PROMPT_CACHING_AWARE, MORPH_ROUTER_ENABLED, } from '../shared/config';
+// Lazy initialization to allow mocking in tests
+let morph = null;
+const sessionsWithModelSelected = new Set();
+function getMorphClient() {
+    if (!morph) {
+        morph = new MorphClient({ apiKey: API_KEY });
+    }
+    return morph;
+}
+function parseModel(s) {
+    if (!s)
+        return { providerID: '', modelID: '' };
+    const [providerID = '', modelID = ''] = s.split('/');
+    return { providerID, modelID };
+}
+function pickModelForDifficulty(difficulty) {
+    const key = String(difficulty).toLowerCase();
+    switch (key) {
+        case 'easy':
+            return parseModel(MORPH_MODEL_EASY);
+        case 'medium':
+            return parseModel(MORPH_MODEL_MEDIUM);
+        case 'hard':
+            return parseModel(MORPH_MODEL_HARD);
+        default:
+            return parseModel(MORPH_MODEL_DEFAULT);
+    }
+}
+export function createModelRouterHook() {
+    return {
+        'chat.message': async (input, output) => {
+            input.model = input.model ?? { providerID: '', modelID: '' };
+            if (!MORPH_ROUTER_ENABLED) {
+                return;
+            }
+            if (MORPH_ROUTER_PROMPT_CACHING_AWARE) {
+                if (sessionsWithModelSelected.has(input.sessionID)) {
+                    return;
+                }
+            }
+            const promptText = extractPromptText(output.parts);
+            const classifier = input.classify ??
+                ((args) => getMorphClient().routers.raw.classify(args));
+            const classification = await classifier({
+                input: promptText,
+            });
+            const chosen = pickModelForDifficulty(classification?.difficulty);
+            const finalProviderID = chosen.providerID || input.model.providerID;
+            const finalModelID = chosen.modelID || input.model.modelID;
+            input.model.providerID = finalProviderID;
+            input.model.modelID = finalModelID;
+            if (MORPH_ROUTER_ENABLED && MORPH_ROUTER_PROMPT_CACHING_AWARE) {
+                sessionsWithModelSelected.add(input.sessionID);
+            }
+        },
+    };
+}
+export function extractPromptText(parts) {
+    return parts
+        .filter((p) => p.type === 'text')
+        .map((p) => p.text || '')
+        .join(' ');
+}

package/dist/morph/router.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/morph/router.test.js

@@ -0,0 +1,239 @@
+import { describe, it, expect, vi } from 'bun:test';
+vi.mock('@morphllm/morphsdk', () => ({
+    MorphClient: vi.fn().mockImplementation(() => ({
+        routers: {
+            raw: {
+                classify: vi.fn(),
+            },
+        },
+    })),
+}));
+vi.mock('../shared/config', () => ({
+    API_KEY: 'sk-test-api-key-123',
+    MORPH_MODEL_EASY: 'easy/easy',
+    MORPH_MODEL_MEDIUM: 'medium/medium',
+    MORPH_MODEL_HARD: 'hard/hard',
+    MORPH_MODEL_DEFAULT: 'default/default',
+    MORPH_ROUTER_PROMPT_CACHING_AWARE: false,
+    MORPH_ROUTER_ENABLED: true,
+}));
+import { createModelRouterHook, extractPromptText } from './router';
+describe('router.ts', () => {
+    describe('extractPromptText', () => {
+        it('should extract text from parts', () => {
+            const parts = [
+                { type: 'text', text: 'Hello' },
+                { type: 'text', text: 'World' },
+            ];
+            expect(extractPromptText(parts)).toBe('Hello World');
+        });
+        it('should handle empty parts', () => {
+            const parts = [];
+            expect(extractPromptText(parts)).toBe('');
+        });
+        it('should filter out non-text parts', () => {
+            const parts = [
+                { type: 'text', text: 'Hello' },
+                { type: 'other', text: 'Ignore' },
+                { type: 'text', text: 'World' },
+            ];
+            expect(extractPromptText(parts)).toBe('Hello World');
+        });
+        it('should handle parts with no text', () => {
+            const parts = [
+                { type: 'text', text: 'Hello' },
+                { type: 'text' },
+                { type: 'text', text: 'World' },
+            ];
+            expect(extractPromptText(parts)).toBe('Hello  World');
+        });
+        it('should handle all non-text parts', () => {
+            const parts = [
+                { type: 'image', data: 'base64...' },
+                { type: 'tool_use', name: 'bash' },
+            ];
+            expect(extractPromptText(parts)).toBe('');
+        });
+    });
+    describe('createModelRouterHook', () => {
+        it('should return a chat.message hook', () => {
+            const hook = createModelRouterHook();
+            expect('chat.message' in hook).toBe(true);
+            expect(typeof hook['chat.message']).toBe('function');
+        });
+        it('should call the classifier with the correct input', async () => {
+            const hook = createModelRouterHook();
+            const classify = vi.fn().mockResolvedValue({ difficulty: 'easy' });
+            const input = {
+                sessionID: '123',
+                classify,
+            };
+            const output = {
+                message: {},
+                parts: [{ type: 'text', text: 'test prompt' }],
+            };
+            await hook['chat.message'](input, output);
+            expect(classify).toHaveBeenCalledWith({ input: 'test prompt' });
+        });
+        it('should assign the correct model based on difficulty', async () => {
+            const hook = createModelRouterHook();
+            const classify = vi.fn().mockResolvedValue({ difficulty: 'hard' });
+            const input = {
+                sessionID: '123',
+                classify,
+            };
+            const output = {
+                message: {},
+                parts: [{ type: 'text', text: 'test prompt' }],
+            };
+            await hook['chat.message'](input, output);
+            expect(input).toHaveProperty('model');
+            expect(input.model.providerID).toBe('hard');
+            expect(input.model.modelID).toBe('hard');
+        });
+        it('should use the default model if no difficulty is returned', async () => {
+            const hook = createModelRouterHook();
+            const classify = vi.fn().mockResolvedValue({});
+            const input = {
+                sessionID: '123',
+                classify,
+            };
+            const output = {
+                message: {},
+                parts: [{ type: 'text', text: 'test prompt' }],
+            };
+            await hook['chat.message'](input, output);
+            expect(input).toHaveProperty('model');
+            expect(input.model.providerID).toBe('default');
+            expect(input.model.modelID).toBe('default');
+        });
+        it('should use default model when router returns nothing', async () => {
+            const hook = createModelRouterHook();
+            const classify = vi.fn().mockResolvedValue({});
+            const input = {
+                sessionID: '123',
+                classify,
+            };
+            const output = {
+                message: {},
+                parts: [{ type: 'text', text: 'test prompt' }],
+            };
+            await hook['chat.message'](input, output);
+            expect(input).toHaveProperty('model');
+            expect(input.model.providerID).toBe('default');
+            expect(input.model.modelID).toBe('default');
+        });
+        it('should handle classifier throwing an error gracefully', async () => {
+            const hook = createModelRouterHook();
+            const classify = vi.fn().mockRejectedValue(new Error('API Error'));
+            const input = {
+                sessionID: '123',
+                classify,
+            };
+            const output = {
+                message: {},
+                parts: [{ type: 'text', text: 'test prompt' }],
+            };
+            await expect(hook['chat.message'](input, output)).rejects.toThrow('API Error');
+        });
+        it('should handle classifier returning null', async () => {
+            const hook = createModelRouterHook();
+            const classify = vi.fn().mockResolvedValue(null);
+            const input = {
+                sessionID: '123',
+                classify,
+            };
+            const output = {
+                message: {},
+                parts: [{ type: 'text', text: 'test prompt' }],
+            };
+            await hook['chat.message'](input, output);
+            expect(input.model.providerID).toBe('default');
+            expect(input.model.modelID).toBe('default');
+        });
+        it('should handle classifier returning undefined difficulty', async () => {
+            const hook = createModelRouterHook();
+            const classify = vi.fn().mockResolvedValue({ difficulty: undefined });
+            const input = {
+                sessionID: '123',
+                classify,
+            };
+            const output = {
+                message: {},
+                parts: [{ type: 'text', text: 'test prompt' }],
+            };
+            await hook['chat.message'](input, output);
+            expect(input.model.providerID).toBe('default');
+            expect(input.model.modelID).toBe('default');
+        });
+        it('should default to default model for invalid difficulty values', async () => {
+            const hook = createModelRouterHook();
+            const classify = vi.fn().mockResolvedValue({ difficulty: 'ultra-hard' });
+            const input = {
+                sessionID: '123',
+                classify,
+            };
+            const output = {
+                message: {},
+                parts: [{ type: 'text', text: 'test prompt' }],
+            };
+            await hook['chat.message'](input, output);
+            expect(input.model.providerID).toBe('default');
+            expect(input.model.modelID).toBe('default');
+        });
+        it('should default to default model for empty string difficulty', async () => {
+            const hook = createModelRouterHook();
+            const classify = vi.fn().mockResolvedValue({ difficulty: '' });
+            const input = {
+                sessionID: '123',
+                classify,
+            };
+            const output = {
+                message: {},
+                parts: [{ type: 'text', text: 'test prompt' }],
+            };
+            await hook['chat.message'](input, output);
+            expect(input.model.providerID).toBe('default');
+            expect(input.model.modelID).toBe('default');
+        });
+        it('should handle case-insensitive difficulty matching', async () => {
+            const hook = createModelRouterHook();
+            const classify = vi.fn().mockResolvedValue({ difficulty: 'HARD' });
+            const input = {
+                sessionID: '123',
+                classify,
+            };
+            const output = {
+                message: {},
+                parts: [{ type: 'text', text: 'test prompt' }],
+            };
+            await hook['chat.message'](input, output);
+            expect(input.model.providerID).toBe('hard');
+            expect(input.model.modelID).toBe('hard');
+        });
+        it('should route all messages when MORPH_ROUTER_PROMPT_CACHING_AWARE is disabled', async () => {
+            const hook = createModelRouterHook();
+            const classify = vi
+                .fn()
+                .mockResolvedValueOnce({ difficulty: 'hard' })
+                .mockResolvedValueOnce({ difficulty: 'easy' });
+            const sessionID = 'session-456';
+            const input1 = { sessionID, classify };
+            const output1 = {
+                message: {},
+                parts: [{ type: 'text', text: 'first message' }],
+            };
+            await hook['chat.message'](input1, output1);
+            expect(classify).toHaveBeenCalledTimes(1);
+            expect(input1.model.providerID).toBe('hard');
+            const input2 = { sessionID, classify };
+            const output2 = {
+                message: {},
+                parts: [{ type: 'text', text: 'second message' }],
+            };
+            await hook['chat.message'](input2, output2);
+            expect(classify).toHaveBeenCalledTimes(2);
+            expect(input2.model.providerID).toBe('easy');
+        });
+    });
+});

package/dist/shared/config.d.ts

@@ -0,0 +1,29 @@
+export declare function getMorphPluginConfigPath(): string;
+interface MorphRouterConfigs {
+    MORPH_ROUTER_ENABLED?: boolean;
+    MORPH_ROUTER_PROMPT_CACHING_AWARE?: boolean;
+    MORPH_MODEL_EASY?: string;
+    MORPH_MODEL_MEDIUM?: string;
+    MORPH_MODEL_HARD?: string;
+    MORPH_MODEL_DEFAULT?: string;
+}
+interface MorphConfig {
+    MORPH_API_KEY?: string;
+    MORPH_ROUTER_CONFIGS?: MorphRouterConfigs;
+    MORPH_ROUTER_ENABLED?: boolean;
+    MORPH_ROUTER_PROMPT_CACHING_AWARE?: boolean;
+    MORPH_MODEL_EASY?: string;
+    MORPH_MODEL_MEDIUM?: string;
+    MORPH_MODEL_HARD?: string;
+    MORPH_MODEL_DEFAULT?: string;
+}
+export declare function loadMorphPluginConfig(): MorphConfig | null;
+export declare function loadMorphPluginConfigWithProjectOverride(projectDir?: string): MorphConfig;
+export declare const API_KEY: string;
+export declare const MORPH_MODEL_EASY: string;
+export declare const MORPH_MODEL_MEDIUM: string;
+export declare const MORPH_MODEL_HARD: string;
+export declare const MORPH_MODEL_DEFAULT: string;
+export declare const MORPH_ROUTER_ENABLED: boolean;
+export declare const MORPH_ROUTER_PROMPT_CACHING_AWARE: boolean;
+export {};