apcore-js 0.1.0

package/tests/registry/test-registry.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect } from 'vitest';
+import { Type } from '@sinclair/typebox';
+import { Registry } from '../../src/registry/registry.js';
+import { FunctionModule } from '../../src/decorator.js';
+import { InvalidInputError, ModuleNotFoundError } from '../../src/errors.js';
+
+function createMod(id: string): FunctionModule {
+  return new FunctionModule({
+    execute: () => ({ ok: true }),
+    moduleId: id,
+    inputSchema: Type.Object({}),
+    outputSchema: Type.Object({ ok: Type.Boolean() }),
+    description: `Module ${id}`,
+  });
+}
+
+describe('Registry', () => {
+  it('creates empty registry', () => {
+    const registry = new Registry();
+    expect(registry.count).toBe(0);
+    expect(registry.list()).toEqual([]);
+  });
+
+  it('register and get module', () => {
+    const registry = new Registry();
+    const mod = createMod('test.a');
+    registry.register('test.a', mod);
+    expect(registry.get('test.a')).toBe(mod);
+    expect(registry.has('test.a')).toBe(true);
+    expect(registry.count).toBe(1);
+  });
+
+  it('get returns null for unknown module', () => {
+    const registry = new Registry();
+    expect(registry.get('unknown')).toBeNull();
+  });
+
+  it('get throws for empty string', () => {
+    const registry = new Registry();
+    expect(() => registry.get('')).toThrow(ModuleNotFoundError);
+  });
+
+  it('register throws for empty moduleId', () => {
+    const registry = new Registry();
+    expect(() => registry.register('', createMod('x'))).toThrow(InvalidInputError);
+  });
+
+  it('register throws for duplicate moduleId', () => {
+    const registry = new Registry();
+    registry.register('test.a', createMod('test.a'));
+    expect(() => registry.register('test.a', createMod('test.a'))).toThrow(InvalidInputError);
+  });
+
+  it('unregister removes module', () => {
+    const registry = new Registry();
+    registry.register('test.a', createMod('test.a'));
+    const removed = registry.unregister('test.a');
+    expect(removed).toBe(true);
+    expect(registry.has('test.a')).toBe(false);
+    expect(registry.count).toBe(0);
+  });
+
+  it('unregister returns false for unknown module', () => {
+    const registry = new Registry();
+    expect(registry.unregister('nonexistent')).toBe(false);
+  });
+
+  it('list returns sorted module IDs', () => {
+    const registry = new Registry();
+    registry.register('b.mod', createMod('b.mod'));
+    registry.register('a.mod', createMod('a.mod'));
+    registry.register('c.mod', createMod('c.mod'));
+    expect(registry.list()).toEqual(['a.mod', 'b.mod', 'c.mod']);
+  });
+
+  it('list filters by prefix', () => {
+    const registry = new Registry();
+    registry.register('foo.a', createMod('foo.a'));
+    registry.register('foo.b', createMod('foo.b'));
+    registry.register('bar.a', createMod('bar.a'));
+    expect(registry.list({ prefix: 'foo.' })).toEqual(['foo.a', 'foo.b']);
+  });
+
+  it('moduleIds returns sorted IDs', () => {
+    const registry = new Registry();
+    registry.register('z.mod', createMod('z.mod'));
+    registry.register('a.mod', createMod('a.mod'));
+    expect(registry.moduleIds).toEqual(['a.mod', 'z.mod']);
+  });
+
+  it('iter returns entries', () => {
+    const registry = new Registry();
+    registry.register('test.a', createMod('test.a'));
+    const entries = [...registry.iter()];
+    expect(entries).toHaveLength(1);
+    expect(entries[0][0]).toBe('test.a');
+  });
+
+  it('on register event fires', () => {
+    const registry = new Registry();
+    const events: string[] = [];
+    registry.on('register', (id) => events.push(id));
+    registry.register('test.a', createMod('test.a'));
+    expect(events).toEqual(['test.a']);
+  });
+
+  it('on unregister event fires', () => {
+    const registry = new Registry();
+    const events: string[] = [];
+    registry.on('unregister', (id) => events.push(id));
+    registry.register('test.a', createMod('test.a'));
+    registry.unregister('test.a');
+    expect(events).toEqual(['test.a']);
+  });
+
+  it('on throws for invalid event', () => {
+    const registry = new Registry();
+    expect(() => registry.on('invalid', () => {})).toThrow(InvalidInputError);
+  });
+
+  it('getDefinition returns descriptor', () => {
+    const registry = new Registry();
+    const mod = createMod('test.a');
+    registry.register('test.a', mod);
+    const def = registry.getDefinition('test.a');
+    expect(def).not.toBeNull();
+    expect(def!.moduleId).toBe('test.a');
+    expect(def!.description).toBe('Module test.a');
+  });
+
+  it('getDefinition returns null for unknown module', () => {
+    const registry = new Registry();
+    expect(registry.getDefinition('nonexistent')).toBeNull();
+  });
+
+  it('clearCache does not throw', () => {
+    const registry = new Registry();
+    registry.clearCache();
+  });
+});

package/tests/registry/test-scanner.test.ts

@@ -0,0 +1,257 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  chmodSync,
+} from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, sep } from 'node:path';
+import { scanExtensions, scanMultiRoot } from '../../src/registry/scanner.js';
+import { ConfigNotFoundError, ConfigError } from '../../src/errors.js';
+
+let tempDir: string;
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), 'scanner-test-'));
+});
+
+afterEach(() => {
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+function touch(relativePath: string, content = ''): string {
+  const full = join(tempDir, relativePath);
+  const dir = full.substring(0, full.lastIndexOf(sep));
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(full, content);
+  return full;
+}
+
+describe('scanExtensions', () => {
+  it('discovers .ts and .js files and returns correct DiscoveredModule shape', () => {
+    touch('alpha.ts');
+    touch('beta.js');
+
+    const results = scanExtensions(tempDir);
+    expect(results).toHaveLength(2);
+    const ids = results.map((r) => r.canonicalId).sort();
+    expect(ids).toEqual(['alpha', 'beta']);
+
+    for (const mod of results) {
+      expect(mod.filePath).toBeTruthy();
+      expect(mod.canonicalId).toBeTruthy();
+      expect(mod.metaPath).toBeNull();
+      expect(mod.namespace).toBeNull();
+    }
+  });
+
+  it('builds dot-notation canonicalId from nested paths', () => {
+    touch('sub/module.ts');
+    touch('deep/nested/handler.js');
+
+    const results = scanExtensions(tempDir);
+    const ids = results.map((r) => r.canonicalId).sort();
+    expect(ids).toEqual(['deep.nested.handler', 'sub.module']);
+  });
+
+  it('skips .d.ts declaration files', () => {
+    touch('real.ts');
+    touch('types.d.ts');
+
+    const results = scanExtensions(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].canonicalId).toBe('real');
+  });
+
+  it('skips .test.ts, .test.js, .spec.ts, and .spec.js files', () => {
+    touch('handler.ts');
+    touch('handler.test.ts');
+    touch('handler.test.js');
+    touch('handler.spec.ts');
+    touch('handler.spec.js');
+
+    const results = scanExtensions(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].canonicalId).toBe('handler');
+  });
+
+  it('skips dot-prefixed and underscore-prefixed entries', () => {
+    touch('.hidden/secret.ts');
+    touch('_private/internal.ts');
+    touch('.env.ts');
+    touch('_helper.ts');
+    touch('visible.ts');
+
+    const results = scanExtensions(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].canonicalId).toBe('visible');
+  });
+
+  it('skips node_modules and __pycache__ directories', () => {
+    touch('node_modules/pkg/index.ts');
+    touch('__pycache__/cached.ts');
+    touch('real.ts');
+
+    const results = scanExtensions(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].canonicalId).toBe('real');
+  });
+
+  it('ignores non-.ts/.js files', () => {
+    touch('readme.md');
+    touch('config.yaml');
+    touch('data.json');
+    touch('valid.ts');
+
+    const results = scanExtensions(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].canonicalId).toBe('valid');
+  });
+
+  it('detects companion _meta.yaml files', () => {
+    touch('handler.ts');
+    touch('handler_meta.yaml', 'description: a handler');
+
+    const results = scanExtensions(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].metaPath).toBe(join(tempDir, 'handler_meta.yaml'));
+  });
+
+  it('sets metaPath to null when no companion _meta.yaml exists', () => {
+    touch('handler.ts');
+    touch('handler_meta.json', '{}');
+
+    const results = scanExtensions(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].metaPath).toBeNull();
+  });
+
+  it('respects maxDepth parameter', () => {
+    touch('level1.ts');
+    touch('a/level2.ts');
+    touch('a/b/level3.ts');
+
+    const resultsDepth1 = scanExtensions(tempDir, 1);
+    expect(resultsDepth1.map((r) => r.canonicalId).sort()).toEqual(['level1']);
+
+    const resultsDepth2 = scanExtensions(tempDir, 2);
+    expect(resultsDepth2.map((r) => r.canonicalId).sort()).toEqual(['a.level2', 'level1']);
+
+    const resultsAll = scanExtensions(tempDir, 8);
+    expect(resultsAll.map((r) => r.canonicalId).sort()).toEqual(['a.b.level3', 'a.level2', 'level1']);
+  });
+
+  it('throws ConfigNotFoundError for non-existent root directory', () => {
+    const bogus = join(tempDir, 'does-not-exist');
+    expect(() => scanExtensions(bogus)).toThrow(ConfigNotFoundError);
+  });
+
+  it('deduplicates by canonicalId (first file wins)', () => {
+    touch('handler.ts');
+    touch('handler.js');
+
+    const results = scanExtensions(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].canonicalId).toBe('handler');
+  });
+
+  it('handles deeply nested structures correctly', () => {
+    touch('a/b/c/d/e/module.ts');
+
+    const results = scanExtensions(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].canonicalId).toBe('a.b.c.d.e.module');
+  });
+
+  it('returns empty array for an empty directory', () => {
+    const results = scanExtensions(tempDir);
+    expect(results).toEqual([]);
+  });
+
+  it('filePath is an absolute path to the discovered file', () => {
+    touch('mod.ts');
+
+    const results = scanExtensions(tempDir);
+    expect(results).toHaveLength(1);
+    expect(results[0].filePath).toBe(join(tempDir, 'mod.ts'));
+  });
+});
+
+describe('scanMultiRoot', () => {
+  it('prefixes canonicalId with namespace', () => {
+    const rootA = join(tempDir, 'rootA');
+    mkdirSync(rootA);
+    writeFileSync(join(rootA, 'handler.ts'), '');
+
+    const results = scanMultiRoot([{ root: rootA, namespace: 'ns1' }]);
+    expect(results).toHaveLength(1);
+    expect(results[0].canonicalId).toBe('ns1.handler');
+    expect(results[0].namespace).toBe('ns1');
+  });
+
+  it('auto-uses directory basename as namespace when not specified', () => {
+    const rootDir = join(tempDir, 'myextensions');
+    mkdirSync(rootDir);
+    writeFileSync(join(rootDir, 'action.ts'), '');
+
+    const results = scanMultiRoot([{ root: rootDir }]);
+    expect(results).toHaveLength(1);
+    expect(results[0].canonicalId).toBe('myextensions.action');
+    expect(results[0].namespace).toBe('myextensions');
+  });
+
+  it('throws ConfigError for duplicate namespaces', () => {
+    const rootA = join(tempDir, 'a');
+    const rootB = join(tempDir, 'b');
+    mkdirSync(rootA);
+    mkdirSync(rootB);
+
+    expect(() =>
+      scanMultiRoot([
+        { root: rootA, namespace: 'dup' },
+        { root: rootB, namespace: 'dup' },
+      ]),
+    ).toThrow(ConfigError);
+  });
+
+  it('merges results from multiple roots', () => {
+    const rootA = join(tempDir, 'rootA');
+    const rootB = join(tempDir, 'rootB');
+    mkdirSync(rootA);
+    mkdirSync(rootB);
+    writeFileSync(join(rootA, 'foo.ts'), '');
+    writeFileSync(join(rootB, 'bar.ts'), '');
+
+    const results = scanMultiRoot([
+      { root: rootA, namespace: 'a' },
+      { root: rootB, namespace: 'b' },
+    ]);
+    expect(results).toHaveLength(2);
+    const ids = results.map((r) => r.canonicalId).sort();
+    expect(ids).toEqual(['a.foo', 'b.bar']);
+  });
+
+  it('propagates ConfigNotFoundError for non-existent root', () => {
+    const bogus = join(tempDir, 'nonexistent');
+    expect(() => scanMultiRoot([{ root: bogus, namespace: 'ns' }])).toThrow(ConfigNotFoundError);
+  });
+
+  it('handles empty roots array', () => {
+    const results = scanMultiRoot([]);
+    expect(results).toEqual([]);
+  });
+
+  it('preserves metaPath through multi-root scan', () => {
+    const rootDir = join(tempDir, 'ext');
+    mkdirSync(rootDir);
+    writeFileSync(join(rootDir, 'mod.ts'), '');
+    writeFileSync(join(rootDir, 'mod_meta.yaml'), 'description: test');
+
+    const results = scanMultiRoot([{ root: rootDir, namespace: 'pkg' }]);
+    expect(results).toHaveLength(1);
+    expect(results[0].metaPath).toBe(join(rootDir, 'mod_meta.yaml'));
+    expect(results[0].canonicalId).toBe('pkg.mod');
+  });
+});

package/tests/registry/test-schema-export.test.ts

@@ -0,0 +1,224 @@
+import { describe, it, expect } from 'vitest';
+import { Type } from '@sinclair/typebox';
+import { Registry } from '../../src/registry/registry.js';
+import { FunctionModule } from '../../src/decorator.js';
+import { ModuleNotFoundError } from '../../src/errors.js';
+import {
+  getSchema,
+  exportSchema,
+  getAllSchemas,
+  exportAllSchemas,
+} from '../../src/registry/schema-export.js';
+
+const inputSchema = Type.Object({
+  prompt: Type.String({ description: 'The input prompt' }),
+  temperature: Type.Optional(Type.Number({ description: 'Sampling temperature' })),
+});
+
+const outputSchema = Type.Object({
+  text: Type.String(),
+});
+
+function createModule(
+  id: string,
+  overrides?: Partial<ConstructorParameters<typeof FunctionModule>[0]>,
+): FunctionModule {
+  return new FunctionModule({
+    execute: () => ({ text: 'hello' }),
+    moduleId: id,
+    inputSchema,
+    outputSchema,
+    description: 'A test module. It does many things.\nSecond paragraph.',
+    tags: ['ai', 'test'],
+    version: '2.0.0',
+    annotations: {
+      readonly: true,
+      destructive: false,
+      idempotent: true,
+      requiresApproval: false,
+      openWorld: false,
+    },
+    examples: [
+      {
+        title: 'Basic example',
+        inputs: { prompt: 'hi' },
+        output: { text: 'hello' },
+        description: 'Simple greeting',
+      },
+    ],
+    ...overrides,
+  });
+}
+
+function makeRegistry(...modules: Array<[string, FunctionModule]>): Registry {
+  const registry = new Registry();
+  for (const [id, mod] of modules) {
+    registry.register(id, mod);
+  }
+  return registry;
+}
+
+describe('getSchema', () => {
+  it('returns null for unregistered module', () => {
+    const registry = new Registry();
+    expect(getSchema(registry, 'no.such.module')).toBeNull();
+  });
+
+  it('returns schema record with all expected fields', () => {
+    const mod = createModule('test.gen');
+    const registry = makeRegistry(['test.gen', mod]);
+
+    const schema = getSchema(registry, 'test.gen');
+    expect(schema).not.toBeNull();
+    expect(schema!['module_id']).toBe('test.gen');
+    expect(schema!['description']).toBe('A test module. It does many things.\nSecond paragraph.');
+    expect(schema!['version']).toBe('2.0.0');
+    expect(schema!['tags']).toEqual(['ai', 'test']);
+    expect(schema!['input_schema']).toBeDefined();
+    expect(schema!['output_schema']).toBeDefined();
+    expect(schema!['examples']).toHaveLength(1);
+  });
+
+  it('copies tags array to prevent mutation', () => {
+    const mod = createModule('test.tags');
+    const registry = makeRegistry(['test.tags', mod]);
+
+    const schema = getSchema(registry, 'test.tags');
+    const tags = schema!['tags'] as string[];
+    tags.push('injected');
+
+    expect(mod.tags).toEqual(['ai', 'test']);
+  });
+
+  it('returns empty array for tags when module has null tags', () => {
+    const mod = createModule('test.notags', { tags: null });
+    const registry = makeRegistry(['test.notags', mod]);
+    const schema = getSchema(registry, 'test.notags');
+    expect(schema!['tags']).toEqual([]);
+  });
+
+  it('returns null annotations when module has no annotations', () => {
+    const mod = createModule('test.noanno', { annotations: null });
+    const registry = makeRegistry(['test.noanno', mod]);
+    const schema = getSchema(registry, 'test.noanno');
+    expect(schema!['annotations']).toBeNull();
+  });
+});
+
+describe('exportSchema', () => {
+  it('returns JSON string by default', () => {
+    const mod = createModule('test.json');
+    const registry = makeRegistry(['test.json', mod]);
+
+    const result = exportSchema(registry, 'test.json');
+    const parsed = JSON.parse(result);
+    expect(parsed['module_id']).toBe('test.json');
+    expect(parsed['version']).toBe('2.0.0');
+  });
+
+  it('returns YAML string when format is yaml', () => {
+    const mod = createModule('test.yaml');
+    const registry = makeRegistry(['test.yaml', mod]);
+
+    const result = exportSchema(registry, 'test.yaml', 'yaml');
+    expect(result).toContain('module_id:');
+    expect(result).toContain('test.yaml');
+  });
+
+  it('throws ModuleNotFoundError for unregistered module', () => {
+    const registry = new Registry();
+    expect(() => exportSchema(registry, 'no.such.module')).toThrow(ModuleNotFoundError);
+  });
+
+  it('applies strict mode to input and output schemas', () => {
+    const mod = createModule('test.strict');
+    const registry = makeRegistry(['test.strict', mod]);
+
+    const result = exportSchema(registry, 'test.strict', 'json', true);
+    const parsed = JSON.parse(result);
+    expect((parsed['input_schema'] as Record<string, unknown>)['additionalProperties']).toBe(false);
+    expect((parsed['output_schema'] as Record<string, unknown>)['additionalProperties']).toBe(false);
+  });
+
+  it('compact mode truncates description at first sentence boundary', () => {
+    const mod = createModule('test.compact');
+    const registry = makeRegistry(['test.compact', mod]);
+
+    const result = exportSchema(registry, 'test.compact', 'json', false, true);
+    const parsed = JSON.parse(result);
+    expect(parsed['description']).toBe('A test module.');
+  });
+
+  it('compact mode removes examples and documentation', () => {
+    const mod = createModule('test.compact.ex', { documentation: 'Full docs' });
+    const registry = makeRegistry(['test.compact.ex', mod]);
+
+    const result = exportSchema(registry, 'test.compact.ex', 'json', false, true);
+    const parsed = JSON.parse(result);
+    expect(parsed['examples']).toBeUndefined();
+    expect(parsed['documentation']).toBeUndefined();
+  });
+
+  it('strict takes precedence over compact when both are true', () => {
+    const mod = createModule('test.both');
+    const registry = makeRegistry(['test.both', mod]);
+
+    const result = exportSchema(registry, 'test.both', 'json', true, true);
+    const parsed = JSON.parse(result);
+    expect((parsed['input_schema'] as Record<string, unknown>)['additionalProperties']).toBe(false);
+    expect(parsed['description']).toBe('A test module. It does many things.\nSecond paragraph.');
+    expect(parsed['examples']).toBeDefined();
+  });
+});
+
+describe('getAllSchemas', () => {
+  it('returns empty object for empty registry', () => {
+    const registry = new Registry();
+    expect(getAllSchemas(registry)).toEqual({});
+  });
+
+  it('returns all module schemas keyed by module id', () => {
+    const modA = createModule('alpha');
+    const modB = createModule('beta', { version: '3.0.0' });
+    const registry = makeRegistry(['alpha', modA], ['beta', modB]);
+
+    const result = getAllSchemas(registry);
+    expect(Object.keys(result).sort()).toEqual(['alpha', 'beta']);
+    expect(result['alpha']['module_id']).toBe('alpha');
+    expect(result['beta']['version']).toBe('3.0.0');
+  });
+});
+
+describe('exportAllSchemas', () => {
+  it('serializes all schemas to JSON', () => {
+    const modA = createModule('a.mod');
+    const modB = createModule('b.mod');
+    const registry = makeRegistry(['a.mod', modA], ['b.mod', modB]);
+
+    const result = exportAllSchemas(registry);
+    const parsed = JSON.parse(result);
+    expect(Object.keys(parsed).sort()).toEqual(['a.mod', 'b.mod']);
+  });
+
+  it('supports YAML format', () => {
+    const mod = createModule('yaml.mod');
+    const registry = makeRegistry(['yaml.mod', mod]);
+
+    const result = exportAllSchemas(registry, 'yaml');
+    expect(result).toContain('yaml.mod');
+  });
+
+  it('applies strict mode to all schemas', () => {
+    const modA = createModule('strict.a');
+    const registry = makeRegistry(['strict.a', modA]);
+
+    const result = exportAllSchemas(registry, 'json', true);
+    const parsed = JSON.parse(result);
+    expect((parsed['strict.a']['input_schema'] as Record<string, unknown>)['additionalProperties']).toBe(false);
+  });
+
+  it('returns empty JSON object for empty registry', () => {
+    const registry = new Registry();
+    expect(JSON.parse(exportAllSchemas(registry))).toEqual({});
+  });
+});

package/tests/registry/test-validation.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+import { Type } from '@sinclair/typebox';
+import { validateModule } from '../../src/registry/validation.js';
+
+describe('validateModule', () => {
+  it('valid module returns no errors', () => {
+    const mod = {
+      inputSchema: Type.Object({}),
+      outputSchema: Type.Object({}),
+      description: 'A test module',
+      execute: () => ({}),
+    };
+    expect(validateModule(mod)).toEqual([]);
+  });
+
+  it('missing inputSchema reports error', () => {
+    const mod = {
+      outputSchema: Type.Object({}),
+      description: 'test',
+      execute: () => ({}),
+    };
+    const errors = validateModule(mod);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors.some(e => e.includes('inputSchema'))).toBe(true);
+  });
+
+  it('missing outputSchema reports error', () => {
+    const mod = {
+      inputSchema: Type.Object({}),
+      description: 'test',
+      execute: () => ({}),
+    };
+    const errors = validateModule(mod);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors.some(e => e.includes('outputSchema'))).toBe(true);
+  });
+
+  it('missing description reports error', () => {
+    const mod = {
+      inputSchema: Type.Object({}),
+      outputSchema: Type.Object({}),
+      execute: () => ({}),
+    };
+    const errors = validateModule(mod);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors.some(e => e.includes('description'))).toBe(true);
+  });
+
+  it('missing execute reports error', () => {
+    const mod = {
+      inputSchema: Type.Object({}),
+      outputSchema: Type.Object({}),
+      description: 'test',
+    };
+    const errors = validateModule(mod);
+    expect(errors.length).toBeGreaterThan(0);
+    expect(errors.some(e => e.includes('execute'))).toBe(true);
+  });
+
+  it('completely empty object reports multiple errors', () => {
+    const errors = validateModule({});
+    expect(errors.length).toBe(4);
+  });
+
+  it('non-function execute reports error', () => {
+    const mod = {
+      inputSchema: Type.Object({}),
+      outputSchema: Type.Object({}),
+      description: 'test',
+      execute: 'not-a-function',
+    };
+    const errors = validateModule(mod);
+    expect(errors.some(e => e.includes('execute'))).toBe(true);
+  });
+});