@williamzujkowski/live-coding-music-mcp 2.0.0 → 4.0.0

package/dist/server/tools/editor.js

@@ -1,126 +1,127 @@
 /**
  * editor domain — pattern editing in the CodeMirror editor.
  *
- * Owns (6 tools): write, append, insert, replace, clear, get_pattern.
- * Post-consolidation per the #110 audit: the five mutating tools
- * collapse into an `edit_pattern` tool with a `mode` enum, while
- * `get_pattern` stays separate (hot read path).
+ * Owns one consolidated mutation tool (`edit_pattern(mode)`) with
+ * write/append/insert/replace/clear modes, plus `get_pattern` (kept
+ * separate — hot read path).
  */
 import { InputValidator } from '../../utils/InputValidator.js';
-export const tools = [
-    {
-        name: 'write',
-        description: 'Write pattern to editor with optional auto-play and validation',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                pattern: { type: 'string', description: 'Pattern code' },
-                auto_play: { type: 'boolean', description: 'Start playback immediately after writing (default: false)' },
-                validate: { type: 'boolean', description: 'Validate pattern before writing (default: true)' },
-            },
-            required: ['pattern'],
-        },
-    },
-    {
-        name: 'append',
-        description: 'Append code to current pattern',
-        inputSchema: {
-            type: 'object',
-            properties: { code: { type: 'string', description: 'Code to append' } },
-            required: ['code'],
-        },
-    },
-    {
-        name: 'insert',
-        description: 'Insert code at specific line',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                position: { type: 'number', description: 'Line number' },
-                code: { type: 'string', description: 'Code to insert' },
-            },
-            required: ['position', 'code'],
-        },
+const SESSION_ID_PROP = {
+    session_id: {
+        type: 'string',
+        description: 'Optional session ID (#108). Omit to use default session.',
     },
+};
+export const tools = [
     {
-        name: 'replace',
-        description: 'Replace pattern section',
+        name: 'edit_pattern',
+        description: 'Mutate the current session pattern. ' +
+            'mode=write replaces the editor contents (default; mirrors the old write tool exactly, including optional pattern validation and auto_play). ' +
+            'mode=append concatenates `code` after the current pattern with a newline. ' +
+            'mode=insert places `code` at the given line `position`. ' +
+            'mode=replace runs a single string-replace from `search` to `replace`. ' +
+            'mode=clear empties the editor. ' +
+            'Example: edit_pattern({ mode: "write", pattern: "s(\\"bd\\")", auto_play: true }). ' +
+            'For reading the editor without mutating it use get_pattern; for the on-disk pattern catalog use pattern_store.',
         inputSchema: {
             type: 'object',
             properties: {
-                search: { type: 'string', description: 'Text to replace' },
-                replace: { type: 'string', description: 'Replacement text' },
+                mode: {
+                    type: 'string',
+                    enum: ['write', 'append', 'insert', 'replace', 'clear'],
+                    description: 'Which edit operation to perform (default: write)',
+                },
+                pattern: { type: 'string', description: 'Pattern code (mode=write)' },
+                code: { type: 'string', description: 'Code to append/insert (mode=append/insert)' },
+                position: { type: 'number', description: 'Line number (mode=insert)' },
+                search: { type: 'string', description: 'Text to replace (mode=replace)' },
+                replace: { type: 'string', description: 'Replacement text (mode=replace)' },
+                auto_play: { type: 'boolean', description: 'Start playback after write (mode=write only, default: false)' },
+                validate: { type: 'boolean', description: 'Validate pattern before write (mode=write only, default: true)' },
+                ...SESSION_ID_PROP,
             },
-            required: ['search', 'replace'],
         },
     },
-    {
-        name: 'clear',
-        description: 'Clear the editor',
-        inputSchema: { type: 'object', properties: {} },
-    },
     {
         name: 'get_pattern',
         description: 'Get current pattern code',
-        inputSchema: { type: 'object', properties: {} },
+        inputSchema: { type: 'object', properties: { ...SESSION_ID_PROP } },
     },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
-export async function execute(name, args, ctx) {
-    switch (name) {
-        case 'write': {
-            InputValidator.validateStringLength(args.pattern, 'pattern', 10000, true);
-            // Validate pattern if requested (default: true) — issue #40
-            if (args.validate !== false && ctx.isInitialized() && typeof ctx.controller.validatePattern === 'function') {
-                try {
-                    const validation = await ctx.controller.validatePattern(args.pattern);
-                    if (validation && !validation.valid) {
-                        return {
-                            success: false,
-                            errors: validation.errors,
-                            warnings: validation.warnings,
-                            suggestions: validation.suggestions,
-                            message: `Pattern validation failed: ${validation.errors.join('; ')}`,
-                        };
-                    }
-                }
-                catch {
-                    ctx.logger.warn('Pattern validation threw error, continuing with write');
-                }
+async function doWrite(args, ctx, sid) {
+    InputValidator.validateStringLength(args.pattern, 'pattern', 10000, true);
+    const controller = ctx.getController(sid);
+    // Validate pattern if requested (default: true) — issue #40
+    if (args.validate !== false && typeof controller.validatePattern === 'function') {
+        try {
+            const validation = await controller.validatePattern(args.pattern);
+            if (validation && !validation.valid) {
+                return {
+                    success: false,
+                    errors: validation.errors,
+                    warnings: validation.warnings,
+                    suggestions: validation.suggestions,
+                    message: `Pattern validation failed: ${validation.errors.join('; ')}`,
+                };
             }
-            const writeResult = await ctx.writePatternSafe(args.pattern);
-            // Auto-play if requested — issue #38
-            if (args.auto_play && ctx.isInitialized()) {
-                await ctx.controller.play();
-                return `${writeResult}. Playing.`;
-            }
-            return writeResult;
-        }
-        case 'append': {
-            InputValidator.validateStringLength(args.code, 'code', 10000, true);
-            const current = await ctx.getCurrentPatternSafe();
-            return await ctx.writePatternSafe(current + '\n' + args.code);
         }
-        case 'insert': {
-            InputValidator.validatePositiveInteger(args.position, 'position');
-            InputValidator.validateStringLength(args.code, 'code', 10000, true);
-            const lines = (await ctx.getCurrentPatternSafe()).split('\n');
-            lines.splice(args.position, 0, args.code);
-            return await ctx.writePatternSafe(lines.join('\n'));
+        catch {
+            ctx.logger.warn('Pattern validation threw error, continuing with write');
         }
-        case 'replace': {
-            InputValidator.validateStringLength(args.search, 'search', 1000, true);
-            InputValidator.validateStringLength(args.replace, 'replace', 10000, true);
-            const pattern = await ctx.getCurrentPatternSafe();
-            // Escape $ in replacement to prevent special sequence injection ($&, $1, $', etc.)
-            const safeReplacement = args.replace.replace(/\$/g, '$$$$');
-            const replaced = pattern.replace(args.search, safeReplacement);
-            return await ctx.writePatternSafe(replaced);
+    }
+    const writeResult = await ctx.writePatternSafe(args.pattern, sid);
+    // Auto-play if requested — issue #38
+    if (args.auto_play) {
+        await controller.play();
+        return `${writeResult}. Playing.`;
+    }
+    return writeResult;
+}
+async function doAppend(args, ctx, sid) {
+    InputValidator.validateStringLength(args.code, 'code', 10000, true);
+    const current = await ctx.getCurrentPatternSafe(sid);
+    return await ctx.writePatternSafe(current + '\n' + args.code, sid);
+}
+async function doInsert(args, ctx, sid) {
+    InputValidator.validatePositiveInteger(args.position, 'position');
+    InputValidator.validateStringLength(args.code, 'code', 10000, true);
+    const lines = (await ctx.getCurrentPatternSafe(sid)).split('\n');
+    lines.splice(args.position, 0, args.code);
+    return await ctx.writePatternSafe(lines.join('\n'), sid);
+}
+async function doReplace(args, ctx, sid) {
+    InputValidator.validateStringLength(args.search, 'search', 1000, true);
+    InputValidator.validateStringLength(args.replace, 'replace', 10000, true);
+    const pattern = await ctx.getCurrentPatternSafe(sid);
+    // Escape $ in replacement to prevent special sequence injection ($&, $1, $', etc.)
+    const safeReplacement = args.replace.replace(/\$/g, '$$$$');
+    const replaced = pattern.replace(args.search, safeReplacement);
+    return await ctx.writePatternSafe(replaced, sid);
+}
+async function doClear(ctx, sid) {
+    return await ctx.writePatternSafe('', sid);
+}
+export async function execute(name, args, ctx) {
+    const sid = args?.session_id;
+    if (!sid && !ctx.isInitialized()) {
+        return 'Browser not initialized. Run init first.';
+    }
+    switch (name) {
+        case 'edit_pattern': {
+            const mode = args?.mode ?? 'write';
+            switch (mode) {
+                case 'write': return await doWrite(args, ctx, sid);
+                case 'append': return await doAppend(args, ctx, sid);
+                case 'insert': return await doInsert(args, ctx, sid);
+                case 'replace': return await doReplace(args, ctx, sid);
+                case 'clear': return await doClear(ctx, sid);
+                default:
+                    throw new Error(`Invalid mode: ${mode}. Must be one of: write, append, insert, replace, clear`);
+            }
         }
-        case 'clear':
-            return await ctx.writePatternSafe('');
         case 'get_pattern':
-            return await ctx.getCurrentPatternSafe();
+            return await ctx.getCurrentPatternSafe(sid);
         default:
             throw new Error(`editor module does not handle tool: ${name}`);
     }

package/dist/server/tools/generate.js

@@ -1,215 +1,186 @@
 /**
  * generate domain — pattern and music-theory generation (no browser needed).
  *
- * Owns (9 tools):
- *   generate_pattern, generate_drums, generate_bassline, generate_melody,
- *   generate_fill, generate_scale, generate_chord_progression,
- *   generate_euclidean, generate_polyrhythm
+ * Owns (3 tools):
+ *   generate_part(role)   — drums/bass/melody/fill layers
+ *   music_theory(query)   — scale notes, chord progressions
+ *   generate_rhythm(type) — euclidean / polyrhythm patterns
  *
- * `compose` stays in server.ts for now — it orchestrates init + generate
- * + play + optional AI feedback and pairs with ai.ts when that extraction
- * happens. Per the #110 audit, compose eventually absorbs generate_pattern
- * and the four generate_* drums/bass/melody/fill tools collapse into
- * `generate_part(role)`, while scale+chord_prog become `music_theory`.
+ * Full-composition generation lives in `compose` (compose.ts), which
+ * orchestrates init + generate + play + optional AI feedback.
  */
 import { InputValidator } from '../../utils/InputValidator.js';
-export const tools = [
-    {
-        name: 'generate_pattern',
-        description: 'Generate complete pattern from style with optional auto-play',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                style: { type: 'string', description: 'Music style (techno/house/dnb/ambient/etc)' },
-                key: { type: 'string', description: 'Musical key' },
-                bpm: { type: 'number', description: 'Tempo in BPM' },
-                auto_play: { type: 'boolean', description: 'Start playback immediately (default: false)' },
-            },
-            required: ['style'],
-        },
-    },
-    {
-        name: 'generate_drums',
-        description: 'Generate drum pattern',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                style: { type: 'string', description: 'Drum style' },
-                complexity: { type: 'number', description: 'Complexity (0-1)' },
-            },
-            required: ['style'],
-        },
-    },
-    {
-        name: 'generate_bassline',
-        description: 'Generate bassline',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                key: { type: 'string', description: 'Musical key' },
-                style: { type: 'string', description: 'Bass style' },
-            },
-            required: ['key', 'style'],
-        },
-    },
-    {
-        name: 'generate_melody',
-        description: 'Generate melody from scale',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                scale: { type: 'string', description: 'Scale name' },
-                root: { type: 'string', description: 'Root note' },
-                length: { type: 'number', description: 'Number of notes' },
-            },
-            required: ['scale', 'root'],
-        },
-    },
-    {
-        name: 'generate_scale',
-        description: 'Generate scale notes',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                root: { type: 'string', description: 'Root note' },
-                scale: { type: 'string', description: 'Scale type' },
-            },
-            required: ['root', 'scale'],
-        },
-    },
-    {
-        name: 'generate_chord_progression',
-        description: 'Generate chord progression',
-        inputSchema: {
-            type: 'object',
-            properties: {
-                key: { type: 'string', description: 'Key' },
-                style: { type: 'string', description: 'Style (pop/jazz/blues/etc)' },
-            },
-            required: ['key', 'style'],
-        },
+const SESSION_ID_PROP = {
+    session_id: {
+        type: 'string',
+        description: 'Optional session ID (#108). Omit to use default session.',
     },
+};
+export const tools = [
     {
-        name: 'generate_euclidean',
-        description: 'Generate Euclidean rhythm',
+        name: 'generate_part',
+        description: 'Generate a single instrumental layer and append it to the current session pattern. ' +
+            'role=drums takes `style` (e.g. "techno"/"house") and optional `complexity` 0-1. ' +
+            'role=bass takes `key` (e.g. "C") + `style`. ' +
+            'role=melody takes `root`/`scale` (e.g. C/minor) and optional `length` (notes). ' +
+            'role=fill takes `style` and optional `bars`. ' +
+            'Example: generate_part({ role: "drums", style: "techno", complexity: 0.7 }). ' +
+            'For full compositions use compose; for rhythmic patterns use generate_rhythm; for music-theory queries use music_theory.',
         inputSchema: {
             type: 'object',
             properties: {
-                hits: { type: 'number', description: 'Number of hits' },
-                steps: { type: 'number', description: 'Total steps' },
-                sound: { type: 'string', description: 'Sound to use' },
+                role: { type: 'string', enum: ['drums', 'bass', 'melody', 'fill'], description: 'Which part to generate' },
+                style: { type: 'string', description: 'role=drums/bass/fill: musical style' },
+                complexity: { type: 'number', description: 'role=drums: complexity 0-1 (default 0.5)' },
+                key: { type: 'string', description: 'role=bass: musical key' },
+                root: { type: 'string', description: 'role=melody: root note' },
+                scale: { type: 'string', description: 'role=melody: scale name' },
+                length: { type: 'number', description: 'role=melody: number of notes (default 8)' },
+                bars: { type: 'number', description: 'role=fill: number of bars (default 1)' },
+                ...SESSION_ID_PROP,
             },
-            required: ['hits', 'steps'],
+            required: ['role'],
         },
     },
     {
-        name: 'generate_polyrhythm',
-        description: 'Generate polyrhythm',
+        name: 'music_theory',
+        description: 'Music-theory queries. ' +
+            'query=scale returns the notes of a scale (e.g. "C major scale: C, D, E, F, G, A, B"). ' +
+            'query=chord_progression returns a chord progression for the key/style AND writes the resulting chord pattern into the current session. ' +
+            'Example: music_theory({ query: "scale", root: "C", scale: "major" }). ' +
+            'For pattern generation (drums/bass/melody) use generate_part; for rhythmic patterns use generate_rhythm.',
         inputSchema: {
             type: 'object',
             properties: {
-                sounds: { type: 'array', items: { type: 'string' }, description: 'Sounds to use' },
-                patterns: { type: 'array', items: { type: 'number' }, description: 'Pattern numbers' },
+                query: { type: 'string', enum: ['scale', 'chord_progression'], description: 'Which theory query' },
+                root: { type: 'string', description: 'Root note (query=scale; also used as key for chord_progression)' },
+                scale: { type: 'string', description: 'Scale type (query=scale)' },
+                key: { type: 'string', description: 'Key (query=chord_progression)' },
+                style: { type: 'string', description: 'Style (query=chord_progression: pop/jazz/blues/etc)' },
+                ...SESSION_ID_PROP,
             },
-            required: ['sounds', 'patterns'],
+            required: ['query'],
         },
     },
     {
-        name: 'generate_fill',
-        description: 'Generate drum fill',
+        name: 'generate_rhythm',
+        description: 'Generate a rhythmic pattern and append it to the current session. ' +
+            'type=euclidean produces a Euclidean rhythm with `hits` evenly distributed across `steps` (optional `sound` param, default "bd"). ' +
+            'type=polyrhythm overlays multiple sound layers with given pattern numbers. ' +
+            'Example: generate_rhythm({ type: "euclidean", hits: 3, steps: 8, sound: "hh" }). ' +
+            'For complete patterns (drums/bass/melody) use generate_part; for whole compositions use compose.',
         inputSchema: {
             type: 'object',
             properties: {
-                style: { type: 'string', description: 'Fill style' },
-                bars: { type: 'number', description: 'Number of bars' },
+                type: { type: 'string', enum: ['euclidean', 'polyrhythm'], description: 'Rhythm type' },
+                hits: { type: 'number', description: 'type=euclidean: hits count' },
+                steps: { type: 'number', description: 'type=euclidean: total steps' },
+                sound: { type: 'string', description: 'type=euclidean: sound to use (default bd)' },
+                sounds: { type: 'array', items: { type: 'string' }, description: 'type=polyrhythm: sounds per layer' },
+                patterns: { type: 'array', items: { type: 'number' }, description: 'type=polyrhythm: pattern numbers per layer' },
+                ...SESSION_ID_PROP,
             },
-            required: ['style'],
+            required: ['type'],
         },
     },
 ];
 export const toolNames = new Set(tools.map(t => t.name));
-async function appendOrSet(generated, ctx) {
-    const current = await ctx.getCurrentPatternSafe();
+async function appendOrSet(generated, ctx, sessionId) {
+    const current = await ctx.getCurrentPatternSafe(sessionId);
     const combined = current ? current + '\n' + generated : generated;
-    await ctx.writePatternSafe(combined);
+    await ctx.writePatternSafe(combined, sessionId);
+}
+function doScale(args, ctx) {
+    InputValidator.validateRootNote(args.root);
+    InputValidator.validateScaleName(args.scale);
+    const notes = ctx.theory.generateScale(args.root, args.scale);
+    return `${args.root} ${args.scale} scale: ${notes.join(', ')}`;
+}
+async function doChordProgression(args, ctx, sid) {
+    InputValidator.validateRootNote(args.key);
+    InputValidator.validateChordStyle(args.style);
+    const progression = ctx.theory.generateChordProgression(args.key, args.style);
+    const chordPattern = ctx.generator.generateChords(progression);
+    await appendOrSet(chordPattern, ctx, sid);
+    return `Generated ${args.style} progression in ${args.key}: ${progression}`;
+}
+async function doEuclidean(args, ctx, sid) {
+    InputValidator.validateEuclidean(args.hits, args.steps);
+    if (args.sound)
+        InputValidator.validateStringLength(args.sound, 'sound', 100, false);
+    const euclidean = ctx.generator.generateEuclideanPattern(args.hits, args.steps, args.sound || 'bd');
+    await appendOrSet(euclidean, ctx, sid);
+    return `Generated Euclidean rhythm (${args.hits}/${args.steps})`;
+}
+async function doPolyrhythm(args, ctx, sid) {
+    args.sounds.forEach((s) => InputValidator.validateStringLength(s, 'sound', 100, false));
+    args.patterns.forEach((p) => InputValidator.validatePositiveInteger(p, 'pattern'));
+    const poly = ctx.generator.generatePolyrhythm(args.sounds, args.patterns);
+    await appendOrSet(poly, ctx, sid);
+    return 'Generated polyrhythm';
+}
+async function doDrums(args, ctx, sid) {
+    InputValidator.validateStringLength(args.style, 'style', 100, false);
+    if (args.complexity !== undefined)
+        InputValidator.validateNormalizedValue(args.complexity, 'complexity');
+    const drums = ctx.generator.generateDrumPattern(args.style, args.complexity || 0.5);
+    await appendOrSet(drums, ctx, sid);
+    return `Generated ${args.style} drums`;
+}
+async function doBassline(args, ctx, sid) {
+    InputValidator.validateRootNote(args.key);
+    InputValidator.validateStringLength(args.style, 'style', 100, false);
+    const bass = ctx.generator.generateBassline(args.key, args.style);
+    await appendOrSet(bass, ctx, sid);
+    return `Generated ${args.style} bassline in ${args.key}`;
+}
+async function doMelody(args, ctx, sid) {
+    InputValidator.validateRootNote(args.root);
+    InputValidator.validateScaleName(args.scale);
+    if (args.length !== undefined)
+        InputValidator.validatePositiveInteger(args.length, 'length');
+    const scale = ctx.theory.generateScale(args.root, args.scale);
+    const melody = ctx.generator.generateMelody(scale, args.length || 8);
+    await appendOrSet(melody, ctx, sid);
+    return `Generated melody in ${args.root} ${args.scale}`;
+}
+async function doFill(args, ctx, sid) {
+    InputValidator.validateStringLength(args.style, 'style', 100, false);
+    if (args.bars !== undefined)
+        InputValidator.validatePositiveInteger(args.bars, 'bars');
+    const fill = ctx.generator.generateFill(args.style, args.bars || 1);
+    await appendOrSet(fill, ctx, sid);
+    return `Generated ${args.bars || 1} bar fill`;
 }
 export async function execute(name, args, ctx) {
+    const sid = args?.session_id;
     switch (name) {
-        case 'generate_pattern': {
-            InputValidator.validateStringLength(args.style, 'style', 100, false);
-            if (args.key)
-                InputValidator.validateRootNote(args.key);
-            if (args.bpm !== undefined)
-                InputValidator.validateBPM(args.bpm);
-            const generated = ctx.generator.generateCompletePattern(args.style, args.key || 'C', args.bpm || 120);
-            await ctx.writePatternSafe(generated);
-            if (args.auto_play && ctx.isInitialized()) {
-                await ctx.controller.play();
-                return `Generated ${args.style} pattern. Playing.`;
+        case 'generate_part': {
+            const role = args?.role;
+            switch (role) {
+                case 'drums': return await doDrums(args, ctx, sid);
+                case 'bass': return await doBassline(args, ctx, sid);
+                case 'melody': return await doMelody(args, ctx, sid);
+                case 'fill': return await doFill(args, ctx, sid);
+                default:
+                    throw new Error(`Invalid role: ${role}. Must be one of: drums, bass, melody, fill`);
             }
-            return `Generated ${args.style} pattern`;
-        }
-        case 'generate_drums': {
-            InputValidator.validateStringLength(args.style, 'style', 100, false);
-            if (args.complexity !== undefined)
-                InputValidator.validateNormalizedValue(args.complexity, 'complexity');
-            const drums = ctx.generator.generateDrumPattern(args.style, args.complexity || 0.5);
-            await appendOrSet(drums, ctx);
-            return `Generated ${args.style} drums`;
         }
-        case 'generate_bassline': {
-            InputValidator.validateRootNote(args.key);
-            InputValidator.validateStringLength(args.style, 'style', 100, false);
-            const bass = ctx.generator.generateBassline(args.key, args.style);
-            await appendOrSet(bass, ctx);
-            return `Generated ${args.style} bassline in ${args.key}`;
-        }
-        case 'generate_melody': {
-            InputValidator.validateRootNote(args.root);
-            InputValidator.validateScaleName(args.scale);
-            if (args.length !== undefined)
-                InputValidator.validatePositiveInteger(args.length, 'length');
-            const scale = ctx.theory.generateScale(args.root, args.scale);
-            const melody = ctx.generator.generateMelody(scale, args.length || 8);
-            await appendOrSet(melody, ctx);
-            return `Generated melody in ${args.root} ${args.scale}`;
-        }
-        case 'generate_scale': {
-            InputValidator.validateRootNote(args.root);
-            InputValidator.validateScaleName(args.scale);
-            const notes = ctx.theory.generateScale(args.root, args.scale);
-            return `${args.root} ${args.scale} scale: ${notes.join(', ')}`;
-        }
-        case 'generate_chord_progression': {
-            InputValidator.validateRootNote(args.key);
-            InputValidator.validateChordStyle(args.style);
-            const progression = ctx.theory.generateChordProgression(args.key, args.style);
-            const chordPattern = ctx.generator.generateChords(progression);
-            await appendOrSet(chordPattern, ctx);
-            return `Generated ${args.style} progression in ${args.key}: ${progression}`;
-        }
-        case 'generate_euclidean': {
-            InputValidator.validateEuclidean(args.hits, args.steps);
-            if (args.sound)
-                InputValidator.validateStringLength(args.sound, 'sound', 100, false);
-            const euclidean = ctx.generator.generateEuclideanPattern(args.hits, args.steps, args.sound || 'bd');
-            await appendOrSet(euclidean, ctx);
-            return `Generated Euclidean rhythm (${args.hits}/${args.steps})`;
-        }
-        case 'generate_polyrhythm': {
-            args.sounds.forEach((s) => InputValidator.validateStringLength(s, 'sound', 100, false));
-            args.patterns.forEach((p) => InputValidator.validatePositiveInteger(p, 'pattern'));
-            const poly = ctx.generator.generatePolyrhythm(args.sounds, args.patterns);
-            await appendOrSet(poly, ctx);
-            return 'Generated polyrhythm';
+        case 'music_theory': {
+            const q = args?.query;
+            if (q !== 'scale' && q !== 'chord_progression') {
+                throw new Error(`Invalid query: ${q}. Must be one of: scale, chord_progression`);
+            }
+            return q === 'scale' ? doScale(args, ctx) : await doChordProgression(args, ctx, sid);
         }
-        case 'generate_fill': {
-            InputValidator.validateStringLength(args.style, 'style', 100, false);
-            if (args.bars !== undefined)
-                InputValidator.validatePositiveInteger(args.bars, 'bars');
-            const fill = ctx.generator.generateFill(args.style, args.bars || 1);
-            await appendOrSet(fill, ctx);
-            return `Generated ${args.bars || 1} bar fill`;
+        case 'generate_rhythm': {
+            const t = args?.type;
+            if (t !== 'euclidean' && t !== 'polyrhythm') {
+                throw new Error(`Invalid type: ${t}. Must be one of: euclidean, polyrhythm`);
+            }
+            return t === 'euclidean'
+                ? await doEuclidean(args, ctx, sid)
+                : await doPolyrhythm(args, ctx, sid);
         }
         default:
             throw new Error(`generate module does not handle tool: ${name}`);