opencode-morphllm 0.0.7 → 0.0.9

package/dist/shared/opencode-config-dir.test.js

@@ -1,310 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from 'bun:test';
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { getOpenCodeConfigDir, getOpenCodeConfigPaths, isDevBuild, detectExistingConfigDir, TAURI_APP_IDENTIFIER, TAURI_APP_IDENTIFIER_DEV, } from './opencode-config-dir';
-describe('opencode-config-dir', () => {
-    let originalPlatform;
-    let originalEnv;
-    beforeEach(() => {
-        originalPlatform = process.platform;
-        originalEnv = {
-            APPDATA: process.env.APPDATA,
-            XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
-            XDG_DATA_HOME: process.env.XDG_DATA_HOME,
-            OPENCODE_CONFIG_DIR: process.env.OPENCODE_CONFIG_DIR,
-        };
-    });
-    afterEach(() => {
-        Object.defineProperty(process, 'platform', { value: originalPlatform });
-        for (const [key, value] of Object.entries(originalEnv)) {
-            if (value !== undefined) {
-                process.env[key] = value;
-            }
-            else {
-                delete process.env[key];
-            }
-        }
-    });
-    describe('OPENCODE_CONFIG_DIR environment variable', () => {
-        test('returns OPENCODE_CONFIG_DIR when env var is set', () => {
-            // #given OPENCODE_CONFIG_DIR is set to a custom path
-            process.env.OPENCODE_CONFIG_DIR = '/custom/opencode/path';
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            // #when getOpenCodeConfigDir is called with binary="opencode"
-            const result = getOpenCodeConfigDir({
-                binary: 'opencode',
-                version: '1.0.200',
-            });
-            // #then returns the custom path
-            expect(result).toBe('/custom/opencode/path');
-        });
-        test('falls back to default when env var is not set', () => {
-            // #given OPENCODE_CONFIG_DIR is not set, platform is Linux
-            delete process.env.OPENCODE_CONFIG_DIR;
-            delete process.env.XDG_CONFIG_HOME;
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            // #when getOpenCodeConfigDir is called with binary="opencode"
-            const result = getOpenCodeConfigDir({
-                binary: 'opencode',
-                version: '1.0.200',
-            });
-            // #then returns default ~/.config/opencode
-            expect(result).toBe(join(homedir(), '.config', 'opencode'));
-        });
-        test('falls back to default when env var is empty string', () => {
-            // #given OPENCODE_CONFIG_DIR is set to empty string
-            process.env.OPENCODE_CONFIG_DIR = '';
-            delete process.env.XDG_CONFIG_HOME;
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            // #when getOpenCodeConfigDir is called with binary="opencode"
-            const result = getOpenCodeConfigDir({
-                binary: 'opencode',
-                version: '1.0.200',
-            });
-            // #then returns default ~/.config/opencode
-            expect(result).toBe(join(homedir(), '.config', 'opencode'));
-        });
-        test('falls back to default when env var is whitespace only', () => {
-            // #given OPENCODE_CONFIG_DIR is set to whitespace only
-            process.env.OPENCODE_CONFIG_DIR = '   ';
-            delete process.env.XDG_CONFIG_HOME;
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            // #when getOpenCodeConfigDir is called with binary="opencode"
-            const result = getOpenCodeConfigDir({
-                binary: 'opencode',
-                version: '1.0.200',
-            });
-            // #then returns default ~/.config/opencode
-            expect(result).toBe(join(homedir(), '.config', 'opencode'));
-        });
-        test('resolves relative path to absolute path', () => {
-            // #given OPENCODE_CONFIG_DIR is set to a relative path
-            process.env.OPENCODE_CONFIG_DIR = './my-opencode-config';
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            // #when getOpenCodeConfigDir is called with binary="opencode"
-            const result = getOpenCodeConfigDir({
-                binary: 'opencode',
-                version: '1.0.200',
-            });
-            // #then returns resolved absolute path
-            expect(result).toBe(resolve('./my-opencode-config'));
-        });
-        test('OPENCODE_CONFIG_DIR takes priority over XDG_CONFIG_HOME', () => {
-            // #given both OPENCODE_CONFIG_DIR and XDG_CONFIG_HOME are set
-            process.env.OPENCODE_CONFIG_DIR = '/custom/opencode/path';
-            process.env.XDG_CONFIG_HOME = '/xdg/config';
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            // #when getOpenCodeConfigDir is called with binary="opencode"
-            const result = getOpenCodeConfigDir({
-                binary: 'opencode',
-                version: '1.0.200',
-            });
-            // #then OPENCODE_CONFIG_DIR takes priority
-            expect(result).toBe('/custom/opencode/path');
-        });
-    });
-    describe('isDevBuild', () => {
-        test('returns false for null version', () => {
-            expect(isDevBuild(null)).toBe(false);
-        });
-        test('returns false for undefined version', () => {
-            expect(isDevBuild(undefined)).toBe(false);
-        });
-        test('returns false for production version', () => {
-            expect(isDevBuild('1.0.200')).toBe(false);
-            expect(isDevBuild('2.1.0')).toBe(false);
-        });
-        test('returns true for version containing -dev', () => {
-            expect(isDevBuild('1.0.0-dev')).toBe(true);
-            expect(isDevBuild('1.0.0-dev.123')).toBe(true);
-        });
-        test('returns true for version containing .dev', () => {
-            expect(isDevBuild('1.0.0.dev')).toBe(true);
-            expect(isDevBuild('1.0.0.dev.456')).toBe(true);
-        });
-    });
-    describe('getOpenCodeConfigDir', () => {
-        describe('for opencode CLI binary', () => {
-            test('returns ~/.config/opencode on Linux', () => {
-                // #given opencode CLI binary detected, platform is Linux
-                Object.defineProperty(process, 'platform', { value: 'linux' });
-                delete process.env.XDG_CONFIG_HOME;
-                delete process.env.OPENCODE_CONFIG_DIR;
-                // #when getOpenCodeConfigDir is called with binary="opencode"
-                const result = getOpenCodeConfigDir({
-                    binary: 'opencode',
-                    version: '1.0.200',
-                });
-                // #then returns ~/.config/opencode
-                expect(result).toBe(join(homedir(), '.config', 'opencode'));
-            });
-            test('returns $XDG_CONFIG_HOME/opencode on Linux when XDG_CONFIG_HOME is set', () => {
-                // #given opencode CLI binary detected, platform is Linux with XDG_CONFIG_HOME set
-                Object.defineProperty(process, 'platform', { value: 'linux' });
-                process.env.XDG_CONFIG_HOME = '/custom/config';
-                delete process.env.OPENCODE_CONFIG_DIR;
-                // #when getOpenCodeConfigDir is called with binary="opencode"
-                const result = getOpenCodeConfigDir({
-                    binary: 'opencode',
-                    version: '1.0.200',
-                });
-                // #then returns $XDG_CONFIG_HOME/opencode
-                expect(result).toBe('/custom/config/opencode');
-            });
-            test('returns ~/.config/opencode on macOS', () => {
-                // #given opencode CLI binary detected, platform is macOS
-                Object.defineProperty(process, 'platform', { value: 'darwin' });
-                delete process.env.XDG_CONFIG_HOME;
-                delete process.env.OPENCODE_CONFIG_DIR;
-                // #when getOpenCodeConfigDir is called with binary="opencode"
-                const result = getOpenCodeConfigDir({
-                    binary: 'opencode',
-                    version: '1.0.200',
-                });
-                // #then returns ~/.config/opencode
-                expect(result).toBe(join(homedir(), '.config', 'opencode'));
-            });
-            test('returns ~/.config/opencode on Windows by default', () => {
-                // #given opencode CLI binary detected, platform is Windows
-                Object.defineProperty(process, 'platform', { value: 'win32' });
-                delete process.env.APPDATA;
-                delete process.env.OPENCODE_CONFIG_DIR;
-                // #when getOpenCodeConfigDir is called with binary="opencode"
-                const result = getOpenCodeConfigDir({
-                    binary: 'opencode',
-                    version: '1.0.200',
-                    checkExisting: false,
-                });
-                // #then returns ~/.config/opencode (cross-platform default)
-                expect(result).toBe(join(homedir(), '.config', 'opencode'));
-            });
-        });
-        describe('for opencode-desktop Tauri binary', () => {
-            test('returns ~/.config/ai.opencode.desktop on Linux', () => {
-                // #given opencode-desktop binary detected, platform is Linux
-                Object.defineProperty(process, 'platform', { value: 'linux' });
-                delete process.env.XDG_CONFIG_HOME;
-                // #when getOpenCodeConfigDir is called with binary="opencode-desktop"
-                const result = getOpenCodeConfigDir({
-                    binary: 'opencode-desktop',
-                    version: '1.0.200',
-                    checkExisting: false,
-                });
-                // #then returns ~/.config/ai.opencode.desktop
-                expect(result).toBe(join(homedir(), '.config', TAURI_APP_IDENTIFIER));
-            });
-            test('returns ~/Library/Application Support/ai.opencode.desktop on macOS', () => {
-                // #given opencode-desktop binary detected, platform is macOS
-                Object.defineProperty(process, 'platform', { value: 'darwin' });
-                // #when getOpenCodeConfigDir is called with binary="opencode-desktop"
-                const result = getOpenCodeConfigDir({
-                    binary: 'opencode-desktop',
-                    version: '1.0.200',
-                    checkExisting: false,
-                });
-                // #then returns ~/Library/Application Support/ai.opencode.desktop
-                expect(result).toBe(join(homedir(), 'Library', 'Application Support', TAURI_APP_IDENTIFIER));
-            });
-            test('returns %APPDATA%/ai.opencode.desktop on Windows', () => {
-                // #given opencode-desktop binary detected, platform is Windows
-                Object.defineProperty(process, 'platform', { value: 'win32' });
-                process.env.APPDATA = 'C:\\Users\\TestUser\\AppData\\Roaming';
-                // #when getOpenCodeConfigDir is called with binary="opencode-desktop"
-                const result = getOpenCodeConfigDir({
-                    binary: 'opencode-desktop',
-                    version: '1.0.200',
-                    checkExisting: false,
-                });
-                // #then returns %APPDATA%/ai.opencode.desktop
-                expect(result).toBe(join('C:\\Users\\TestUser\\AppData\\Roaming', TAURI_APP_IDENTIFIER));
-            });
-        });
-        describe('dev build detection', () => {
-            test('returns ai.opencode.desktop.dev path when dev version detected', () => {
-                // #given opencode-desktop dev version
-                Object.defineProperty(process, 'platform', { value: 'linux' });
-                delete process.env.XDG_CONFIG_HOME;
-                // #when getOpenCodeConfigDir is called with dev version
-                const result = getOpenCodeConfigDir({
-                    binary: 'opencode-desktop',
-                    version: '1.0.0-dev.123',
-                    checkExisting: false,
-                });
-                // #then returns path with ai.opencode.desktop.dev
-                expect(result).toBe(join(homedir(), '.config', TAURI_APP_IDENTIFIER_DEV));
-            });
-            test('returns ai.opencode.desktop.dev on macOS for dev build', () => {
-                // #given opencode-desktop dev version on macOS
-                Object.defineProperty(process, 'platform', { value: 'darwin' });
-                // #when getOpenCodeConfigDir is called with dev version
-                const result = getOpenCodeConfigDir({
-                    binary: 'opencode-desktop',
-                    version: '1.0.0-dev',
-                    checkExisting: false,
-                });
-                // #then returns path with ai.opencode.desktop.dev
-                expect(result).toBe(join(homedir(), 'Library', 'Application Support', TAURI_APP_IDENTIFIER_DEV));
-            });
-        });
-    });
-    describe('getOpenCodeConfigPaths', () => {
-        test('returns all config paths for CLI binary', () => {
-            // #given opencode CLI binary on Linux
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            delete process.env.XDG_CONFIG_HOME;
-            delete process.env.OPENCODE_CONFIG_DIR;
-            // #when getOpenCodeConfigPaths is called
-            const paths = getOpenCodeConfigPaths({
-                binary: 'opencode',
-                version: '1.0.200',
-            });
-            // #then returns all expected paths
-            const expectedDir = join(homedir(), '.config', 'opencode');
-            expect(paths.configDir).toBe(expectedDir);
-            expect(paths.configJson).toBe(join(expectedDir, 'opencode.json'));
-            expect(paths.configJsonc).toBe(join(expectedDir, 'opencode.jsonc'));
-            expect(paths.packageJson).toBe(join(expectedDir, 'package.json'));
-            expect(paths.omoConfig).toBe(join(expectedDir, 'oh-my-opencode.json'));
-        });
-        test('returns all config paths for desktop binary', () => {
-            // #given opencode-desktop binary on macOS
-            Object.defineProperty(process, 'platform', { value: 'darwin' });
-            // #when getOpenCodeConfigPaths is called
-            const paths = getOpenCodeConfigPaths({
-                binary: 'opencode-desktop',
-                version: '1.0.200',
-                checkExisting: false,
-            });
-            // #then returns all expected paths
-            const expectedDir = join(homedir(), 'Library', 'Application Support', TAURI_APP_IDENTIFIER);
-            expect(paths.configDir).toBe(expectedDir);
-            expect(paths.configJson).toBe(join(expectedDir, 'opencode.json'));
-            expect(paths.configJsonc).toBe(join(expectedDir, 'opencode.jsonc'));
-            expect(paths.packageJson).toBe(join(expectedDir, 'package.json'));
-            expect(paths.omoConfig).toBe(join(expectedDir, 'oh-my-opencode.json'));
-        });
-    });
-    describe('detectExistingConfigDir', () => {
-        test('returns null when no config exists', () => {
-            // #given no config files exist
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            delete process.env.XDG_CONFIG_HOME;
-            delete process.env.OPENCODE_CONFIG_DIR;
-            // #when detectExistingConfigDir is called
-            const result = detectExistingConfigDir('opencode', '1.0.200');
-            // #then result is either null or a valid string path
-            expect(result === null || typeof result === 'string').toBe(true);
-        });
-        test('includes OPENCODE_CONFIG_DIR in search locations when set', () => {
-            // #given OPENCODE_CONFIG_DIR is set to a custom path
-            process.env.OPENCODE_CONFIG_DIR = '/custom/opencode/path';
-            Object.defineProperty(process, 'platform', { value: 'linux' });
-            delete process.env.XDG_CONFIG_HOME;
-            // #when detectExistingConfigDir is called
-            const result = detectExistingConfigDir('opencode', '1.0.200');
-            // #then result is either null (no config file exists) or a valid string path
-            // The important thing is that the function doesn't throw
-            expect(result === null || typeof result === 'string').toBe(true);
-        });
-    });
-});

package/src/index.ts

@@ -1,22 +0,0 @@
-import { Plugin } from '@opencode-ai/plugin';
-import type { McpLocalConfig } from '@opencode-ai/sdk';
-
-import { createBuiltinMcps } from './morph/mcps';
-import { createModelRouterHook } from './morph/router';
-
-const MorphOpenCodePlugin: Plugin = async () => {
-  const builtinMcps: Record<string, McpLocalConfig> = createBuiltinMcps();
-  const routerHook = createModelRouterHook();
-
-  return {
-    config: async (currentConfig: any) => {
-      currentConfig.mcp = {
-        ...currentConfig.mcp,
-        ...builtinMcps,
-      };
-    },
-    ...routerHook,
-  };
-};
-
-export default MorphOpenCodePlugin;

package/src/morph/mcps.test.ts

@@ -1,51 +0,0 @@
-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/src/morph/mcps.ts

@@ -1,18 +0,0 @@
-import type { McpLocalConfig } from '@opencode-ai/sdk';
-import { API_KEY } from '../shared/config';
-
-export function createBuiltinMcps(): Record<string, McpLocalConfig> {
-  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/src/morph/router.test.ts

@@ -1,267 +0,0 @@
-import { describe, it, expect, vi } from 'bun:test';
-import type { Part } from '@opencode-ai/sdk';
-
-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: Part[] = [
-        { type: 'text', text: 'Hello' },
-        { type: 'text', text: 'World' },
-      ] as any;
-      expect(extractPromptText(parts)).toBe('Hello World');
-    });
-
-    it('should handle empty parts', () => {
-      const parts: Part[] = [];
-      expect(extractPromptText(parts)).toBe('');
-    });
-
-    it('should filter out non-text parts', () => {
-      const parts: Part[] = [
-        { type: 'text', text: 'Hello' },
-        { type: 'other', text: 'Ignore' },
-        { type: 'text', text: 'World' },
-      ] as any;
-      expect(extractPromptText(parts)).toBe('Hello World');
-    });
-
-    it('should handle parts with no text', () => {
-      const parts: Part[] = [
-        { type: 'text', text: 'Hello' },
-        { type: 'text' },
-        { type: 'text', text: 'World' },
-      ] as any;
-      expect(extractPromptText(parts)).toBe('Hello  World');
-    });
-
-    it('should handle all non-text parts', () => {
-      const parts: Part[] = [
-        { type: 'image', data: 'base64...' },
-        { type: 'tool_use', name: 'bash' },
-      ] as any;
-      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: {} as any,
-        parts: [{ type: 'text', text: 'test prompt' }],
-      } as any;
-      await hook['chat.message'](input as any, 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: {} as any,
-        parts: [{ type: 'text', text: 'test prompt' }],
-      } as any;
-      await hook['chat.message'](input as any, output);
-      expect(input).toHaveProperty('model');
-      expect((input as any).model.providerID).toBe('hard');
-      expect((input as any).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: {} as any,
-        parts: [{ type: 'text', text: 'test prompt' }],
-      } as any;
-      await hook['chat.message'](input as any, output);
-      expect(input).toHaveProperty('model');
-      expect((input as any).model.providerID).toBe('default');
-      expect((input as any).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: {} as any,
-        parts: [{ type: 'text', text: 'test prompt' }],
-      } as any;
-      await hook['chat.message'](input as any, output);
-      expect(input).toHaveProperty('model');
-      expect((input as any).model.providerID).toBe('default');
-      expect((input as any).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: {} as any,
-        parts: [{ type: 'text', text: 'test prompt' }],
-      } as any;
-
-      await expect(hook['chat.message'](input as any, 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: {} as any,
-        parts: [{ type: 'text', text: 'test prompt' }],
-      } as any;
-      await hook['chat.message'](input as any, output);
-      expect((input as any).model.providerID).toBe('default');
-      expect((input as any).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: {} as any,
-        parts: [{ type: 'text', text: 'test prompt' }],
-      } as any;
-      await hook['chat.message'](input as any, output);
-      expect((input as any).model.providerID).toBe('default');
-      expect((input as any).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: {} as any,
-        parts: [{ type: 'text', text: 'test prompt' }],
-      } as any;
-      await hook['chat.message'](input as any, output);
-      expect((input as any).model.providerID).toBe('default');
-      expect((input as any).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: {} as any,
-        parts: [{ type: 'text', text: 'test prompt' }],
-      } as any;
-      await hook['chat.message'](input as any, output);
-      expect((input as any).model.providerID).toBe('default');
-      expect((input as any).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: {} as any,
-        parts: [{ type: 'text', text: 'test prompt' }],
-      } as any;
-      await hook['chat.message'](input as any, output);
-      expect((input as any).model.providerID).toBe('hard');
-      expect((input as any).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: {} as any,
-        parts: [{ type: 'text', text: 'first message' }],
-      } as any;
-
-      await hook['chat.message'](input1 as any, output1);
-      expect(classify).toHaveBeenCalledTimes(1);
-      expect((input1 as any).model.providerID).toBe('hard');
-
-      const input2 = { sessionID, classify };
-      const output2 = {
-        message: {} as any,
-        parts: [{ type: 'text', text: 'second message' }],
-      } as any;
-
-      await hook['chat.message'](input2 as any, output2);
-      expect(classify).toHaveBeenCalledTimes(2);
-      expect((input2 as any).model.providerID).toBe('easy');
-    });
-  });
-});