signalwire-agents 0.1.0

package/tests/Logger.test.ts

@@ -0,0 +1,218 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { Logger, getLogger, setGlobalLogLevel, suppressAllLogs, setGlobalLogFormat, setGlobalLogColor, resetLoggingConfiguration } from '../src/Logger.js';
+
+describe('Logger', () => {
+  let spyDebug: ReturnType<typeof vi.spyOn>;
+  let spyInfo: ReturnType<typeof vi.spyOn>;
+  let spyWarn: ReturnType<typeof vi.spyOn>;
+  let spyError: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    spyDebug = vi.spyOn(console, 'debug').mockImplementation(() => {});
+    spyInfo = vi.spyOn(console, 'info').mockImplementation(() => {});
+    spyWarn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    spyError = vi.spyOn(console, 'error').mockImplementation(() => {});
+    setGlobalLogLevel('debug');
+    setGlobalLogColor(false);
+    setGlobalLogFormat('text');
+    suppressAllLogs(false);
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    setGlobalLogLevel('info');
+    setGlobalLogFormat('text');
+    setGlobalLogColor(false);
+    suppressAllLogs(false);
+  });
+
+  it('getLogger returns Logger instance', () => {
+    const log = getLogger('test');
+    expect(log).toBeInstanceOf(Logger);
+  });
+
+  it('logs at debug level', () => {
+    const log = getLogger('mymod');
+    log.debug('hello');
+    expect(spyDebug).toHaveBeenCalledWith('[DEBUG] [mymod] hello');
+  });
+
+  it('logs at info level', () => {
+    const log = getLogger('mymod');
+    log.info('world');
+    expect(spyInfo).toHaveBeenCalledWith('[INFO] [mymod] world');
+  });
+
+  it('logs at warn level', () => {
+    const log = getLogger('mymod');
+    log.warn('caution');
+    expect(spyWarn).toHaveBeenCalledWith('[WARN] [mymod] caution');
+  });
+
+  it('logs at error level', () => {
+    const log = getLogger('mymod');
+    log.error('failure');
+    expect(spyError).toHaveBeenCalledWith('[ERROR] [mymod] failure');
+  });
+
+  it('includes data object in output', () => {
+    const log = getLogger('test');
+    log.info('msg', { key: 'val' });
+    expect(spyInfo).toHaveBeenCalledWith('[INFO] [test] msg {"key":"val"}');
+  });
+
+  it('respects log level filtering', () => {
+    setGlobalLogLevel('warn');
+    const log = getLogger('test');
+    log.debug('hidden');
+    log.info('hidden');
+    log.warn('shown');
+    log.error('shown');
+    expect(spyDebug).not.toHaveBeenCalled();
+    expect(spyInfo).not.toHaveBeenCalled();
+    expect(spyWarn).toHaveBeenCalledOnce();
+    expect(spyError).toHaveBeenCalledOnce();
+  });
+
+  it('setGlobalLogLevel changes level', () => {
+    setGlobalLogLevel('error');
+    const log = getLogger('test');
+    log.warn('nope');
+    log.error('yes');
+    expect(spyWarn).not.toHaveBeenCalled();
+    expect(spyError).toHaveBeenCalledOnce();
+  });
+
+  it('suppressAllLogs suppresses everything', () => {
+    suppressAllLogs(true);
+    const log = getLogger('test');
+    log.debug('nope');
+    log.info('nope');
+    log.warn('nope');
+    log.error('nope');
+    expect(spyDebug).not.toHaveBeenCalled();
+    expect(spyInfo).not.toHaveBeenCalled();
+    expect(spyWarn).not.toHaveBeenCalled();
+    expect(spyError).not.toHaveBeenCalled();
+  });
+
+  it('suppressAllLogs can be turned off', () => {
+    suppressAllLogs(true);
+    const log = getLogger('test');
+    log.info('hidden');
+    expect(spyInfo).not.toHaveBeenCalled();
+    suppressAllLogs(false);
+    log.info('shown');
+    expect(spyInfo).toHaveBeenCalledOnce();
+  });
+
+  it('empty data object does not append to output', () => {
+    const log = getLogger('test');
+    log.info('clean', {});
+    expect(spyInfo).toHaveBeenCalledWith('[INFO] [test] clean');
+  });
+
+  it('debug level shows all messages', () => {
+    setGlobalLogLevel('debug');
+    const log = getLogger('test');
+    log.debug('d');
+    log.info('i');
+    log.warn('w');
+    log.error('e');
+    expect(spyDebug).toHaveBeenCalledOnce();
+    expect(spyInfo).toHaveBeenCalledOnce();
+    expect(spyWarn).toHaveBeenCalledOnce();
+    expect(spyError).toHaveBeenCalledOnce();
+  });
+
+  // ── Pass 2: New logger features ──────────────────────────────────
+
+  it('JSON format outputs structured JSON', () => {
+    setGlobalLogFormat('json');
+    const log = getLogger('mymod');
+    log.info('hello world');
+    expect(spyInfo).toHaveBeenCalledOnce();
+    const output = spyInfo.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.level).toBe('info');
+    expect(parsed.logger).toBe('mymod');
+    expect(parsed.message).toBe('hello world');
+    expect(parsed.timestamp).toBeDefined();
+  });
+
+  it('JSON format includes data fields', () => {
+    setGlobalLogFormat('json');
+    const log = getLogger('test');
+    log.warn('alert', { code: 500, path: '/api' });
+    const output = spyWarn.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.code).toBe(500);
+    expect(parsed.path).toBe('/api');
+  });
+
+  it('bind creates child logger with context', () => {
+    const log = getLogger('test');
+    const child = log.bind({ callId: 'call-42', function: 'get_time' });
+    child.info('processing');
+    const output = spyInfo.mock.calls[0][0] as string;
+    expect(output).toContain('"callId":"call-42"');
+    expect(output).toContain('"function":"get_time"');
+  });
+
+  it('bind context merges with log data', () => {
+    const log = getLogger('test').bind({ callId: 'c1' });
+    log.info('msg', { extra: true });
+    const output = spyInfo.mock.calls[0][0] as string;
+    expect(output).toContain('"callId":"c1"');
+    expect(output).toContain('"extra":true');
+  });
+
+  it('bind context can be chained', () => {
+    const log = getLogger('test')
+      .bind({ callId: 'c1' })
+      .bind({ step: 'auth' });
+    log.info('ok');
+    const output = spyInfo.mock.calls[0][0] as string;
+    expect(output).toContain('"callId":"c1"');
+    expect(output).toContain('"step":"auth"');
+  });
+
+  it('color output includes ANSI codes', () => {
+    setGlobalLogColor(true);
+    const log = getLogger('test');
+    log.info('colorful');
+    const output = spyInfo.mock.calls[0][0] as string;
+    expect(output).toContain('\x1b[32m'); // green for info
+    expect(output).toContain('\x1b[0m'); // reset
+  });
+
+  it('no ANSI codes when color disabled', () => {
+    setGlobalLogColor(false);
+    const log = getLogger('test');
+    log.error('plain');
+    const output = spyError.mock.calls[0][0] as string;
+    expect(output).not.toContain('\x1b[');
+  });
+
+  it('resetLoggingConfiguration restores defaults', () => {
+    setGlobalLogLevel('error');
+    setGlobalLogFormat('json');
+    suppressAllLogs(true);
+    resetLoggingConfiguration();
+    // After reset, should use env vars or defaults
+    const log = getLogger('test');
+    log.info('after reset');
+    // Since logs were re-enabled and level reset to 'info', this should log
+    expect(spyInfo).toHaveBeenCalledOnce();
+  });
+
+  it('JSON format in bind context', () => {
+    setGlobalLogFormat('json');
+    const log = getLogger('test').bind({ reqId: 'r1' });
+    log.debug('check');
+    const output = spyDebug.mock.calls[0][0] as string;
+    const parsed = JSON.parse(output);
+    expect(parsed.reqId).toBe('r1');
+    expect(parsed.message).toBe('check');
+  });
+});

package/tests/PomBuilder.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect } from 'vitest';
+import { PomBuilder, PomSection } from '../src/PomBuilder.js';
+import { SwmlBuilder } from '../src/SwmlBuilder.js';
+
+describe('PomSection', () => {
+  it('toDict includes only non-empty fields', () => {
+    const s = new PomSection({ title: 'Hello', body: 'World' });
+    const d = s.toDict();
+    expect(d.title).toBe('Hello');
+    expect(d.body).toBe('World');
+    expect(d.bullets).toBeUndefined();
+    expect(d.subsections).toBeUndefined();
+  });
+
+  it('renderMarkdown produces heading + body', () => {
+    const s = new PomSection({ title: 'Title', body: 'Body text' });
+    const md = s.renderMarkdown();
+    expect(md).toContain('## Title');
+    expect(md).toContain('Body text');
+  });
+
+  it('renderMarkdown with bullets', () => {
+    const s = new PomSection({ title: 'T', bullets: ['a', 'b'] });
+    const md = s.renderMarkdown();
+    expect(md).toContain('- a');
+    expect(md).toContain('- b');
+  });
+
+  it('renderMarkdown with numbered bullets', () => {
+    const s = new PomSection({ title: 'T', bullets: ['a', 'b'], numberedBullets: true });
+    const md = s.renderMarkdown();
+    expect(md).toContain('1. a');
+    expect(md).toContain('2. b');
+  });
+});
+
+describe('PomBuilder', () => {
+  it('addSection and toDict', () => {
+    const b = new PomBuilder()
+      .addSection('Role', { body: 'You are a helper' })
+      .addSection('Rules', { bullets: ['Be nice', 'Be helpful'] });
+
+    const dict = b.toDict();
+    expect(dict.length).toBe(2);
+    expect(dict[0].title).toBe('Role');
+    expect(dict[0].body).toBe('You are a helper');
+    expect(dict[1].bullets).toEqual(['Be nice', 'Be helpful']);
+  });
+
+  it('addToSection creates section if missing', () => {
+    const b = new PomBuilder().addToSection('New', { body: 'hello' });
+    expect(b.hasSection('New')).toBe(true);
+    expect(b.toDict()[0].body).toBe('hello');
+  });
+
+  it('addToSection appends body', () => {
+    const b = new PomBuilder()
+      .addSection('S', { body: 'line1' })
+      .addToSection('S', { body: 'line2' });
+    expect(b.getSection('S')!.body).toBe('line1\n\nline2');
+  });
+
+  it('addToSection appends bullets', () => {
+    const b = new PomBuilder()
+      .addSection('S', { bullets: ['a'] })
+      .addToSection('S', { bullet: 'b' })
+      .addToSection('S', { bullets: ['c', 'd'] });
+    expect(b.getSection('S')!.bullets).toEqual(['a', 'b', 'c', 'd']);
+  });
+
+  it('addSubsection', () => {
+    const b = new PomBuilder()
+      .addSection('Parent')
+      .addSubsection('Parent', 'Child', { body: 'child body' });
+
+    const dict = b.toDict();
+    expect(dict[0].subsections!.length).toBe(1);
+    expect(dict[0].subsections![0].title).toBe('Child');
+  });
+
+  it('addSubsection auto-creates parent', () => {
+    const b = new PomBuilder().addSubsection('P', 'C', { body: 'x' });
+    expect(b.hasSection('P')).toBe(true);
+    expect(b.toDict()[0].subsections![0].title).toBe('C');
+  });
+
+  it('hasSection / getSection / findSection', () => {
+    const b = new PomBuilder()
+      .addSection('Top')
+      .addSubsection('Top', 'Nested', { body: 'x' });
+
+    expect(b.hasSection('Top')).toBe(true);
+    expect(b.hasSection('Missing')).toBe(false);
+    expect(b.getSection('Top')).toBeDefined();
+    expect(b.findSection('Nested')).toBeDefined();
+    expect(b.findSection('Missing')).toBeUndefined();
+  });
+
+  it('renderMarkdown produces valid markdown', () => {
+    const b = new PomBuilder()
+      .addSection('Persona', { body: 'You are helpful' })
+      .addSection('Rules', { bullets: ['Be nice', 'Be clear'] });
+
+    const md = b.renderMarkdown();
+    expect(md).toContain('## Persona');
+    expect(md).toContain('You are helpful');
+    expect(md).toContain('## Rules');
+    expect(md).toContain('- Be nice');
+  });
+
+  it('addSection with subsections in options', () => {
+    const b = new PomBuilder().addSection('Root', {
+      body: 'root body',
+      subsections: [
+        { title: 'Sub1', body: 'sub1 body' },
+        { title: 'Sub2', bullets: ['x'] },
+      ],
+    });
+    const dict = b.toDict();
+    expect(dict[0].subsections!.length).toBe(2);
+  });
+});
+
+describe('SwmlBuilder', () => {
+  it('creates empty document', () => {
+    const b = new SwmlBuilder();
+    const doc = b.getDocument();
+    expect(doc['version']).toBe('1.0.0');
+    expect((doc['sections'] as Record<string, unknown[]>)['main']).toEqual([]);
+  });
+
+  it('addVerb', () => {
+    const b = new SwmlBuilder();
+    b.addVerb('answer', {});
+    b.addVerb('ai', { prompt: { text: 'hello' } });
+    const main = (b.getDocument()['sections'] as Record<string, unknown[]>)['main'];
+    expect(main.length).toBe(2);
+    expect(main[0]).toEqual({ answer: {} });
+  });
+
+  it('addVerbToSection creates section', () => {
+    const b = new SwmlBuilder();
+    b.addVerbToSection('custom', 'play', { url: 'test.mp3' });
+    const sections = b.getDocument()['sections'] as Record<string, unknown[]>;
+    expect(sections['custom']).toBeDefined();
+    expect(sections['custom'][0]).toEqual({ play: { url: 'test.mp3' } });
+  });
+
+  it('reset clears document', () => {
+    const b = new SwmlBuilder();
+    b.addVerb('answer', {});
+    b.reset();
+    const main = (b.getDocument()['sections'] as Record<string, unknown[]>)['main'];
+    expect(main).toEqual([]);
+  });
+
+  it('renderDocument returns JSON', () => {
+    const b = new SwmlBuilder();
+    b.addVerb('answer', {});
+    const json = b.renderDocument();
+    const parsed = JSON.parse(json);
+    expect(parsed.version).toBe('1.0.0');
+  });
+});

package/tests/ProxyDetection.test.ts

@@ -0,0 +1,185 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { AgentBase } from '../src/AgentBase.js';
+
+describe('ProxyDetection', () => {
+  let agent: AgentBase;
+
+  beforeEach(() => {
+    // Clear env vars that could interfere
+    delete process.env['SWML_PROXY_URL_BASE'];
+    delete process.env['SWML_PROXY_DEBUG'];
+    agent = new AgentBase({ name: 'proxy-test', route: '/', basicAuth: ['user', 'pass'] });
+    agent.setPromptText('test prompt');
+  });
+
+  it('getFullUrl returns localhost by default', () => {
+    const url = agent.getFullUrl();
+    expect(url).toContain('localhost');
+  });
+
+  it('manualSetProxyUrl overrides getFullUrl', () => {
+    agent.manualSetProxyUrl('https://tunnel.example.com');
+    const url = agent.getFullUrl();
+    expect(url).toBe('https://tunnel.example.com');
+  });
+
+  it('manualSetProxyUrl strips trailing slashes', () => {
+    agent.manualSetProxyUrl('https://tunnel.example.com///');
+    const url = agent.getFullUrl();
+    expect(url).toBe('https://tunnel.example.com');
+  });
+
+  it('manualSetProxyUrl with auth', () => {
+    agent.manualSetProxyUrl('https://tunnel.example.com');
+    const url = agent.getFullUrl(true);
+    expect(url).toBe('https://user:pass@tunnel.example.com');
+  });
+
+  it('detects proxy from X-Forwarded-Host in SWML request', async () => {
+    const app = agent.getApp();
+    const res = await app.request('http://localhost/', {
+      method: 'POST',
+      headers: {
+        'Authorization': 'Basic ' + btoa('user:pass'),
+        'Content-Type': 'application/json',
+        'X-Forwarded-Host': 'ngrok.example.com',
+        'X-Forwarded-Proto': 'https',
+      },
+      body: JSON.stringify({}),
+    });
+    expect(res.status).toBe(200);
+    // After request, the agent should have detected the proxy
+    expect(agent.getFullUrl()).toBe('https://ngrok.example.com');
+  });
+
+  it('detects proxy from X-Forwarded-Host defaults to https', async () => {
+    const app = agent.getApp();
+    await app.request('http://localhost/', {
+      method: 'POST',
+      headers: {
+        'Authorization': 'Basic ' + btoa('user:pass'),
+        'Content-Type': 'application/json',
+        'X-Forwarded-Host': 'tunnel.io',
+      },
+      body: JSON.stringify({}),
+    });
+    expect(agent.getFullUrl()).toBe('https://tunnel.io');
+  });
+
+  it('detects proxy from Forwarded header (RFC 7239)', async () => {
+    const app = agent.getApp();
+    await app.request('http://localhost/', {
+      method: 'POST',
+      headers: {
+        'Authorization': 'Basic ' + btoa('user:pass'),
+        'Content-Type': 'application/json',
+        'Forwarded': 'host=proxy.example.com;proto=https',
+      },
+      body: JSON.stringify({}),
+    });
+    expect(agent.getFullUrl()).toBe('https://proxy.example.com');
+  });
+
+  it('detects proxy from Forwarded header with default proto', async () => {
+    const app = agent.getApp();
+    await app.request('http://localhost/', {
+      method: 'POST',
+      headers: {
+        'Authorization': 'Basic ' + btoa('user:pass'),
+        'Content-Type': 'application/json',
+        'Forwarded': 'host=proxy.example.com',
+      },
+      body: JSON.stringify({}),
+    });
+    expect(agent.getFullUrl()).toBe('https://proxy.example.com');
+  });
+
+  it('detects proxy from X-Original-Host', async () => {
+    const app = agent.getApp();
+    await app.request('http://localhost/', {
+      method: 'POST',
+      headers: {
+        'Authorization': 'Basic ' + btoa('user:pass'),
+        'Content-Type': 'application/json',
+        'X-Original-Host': 'original.example.com',
+      },
+      body: JSON.stringify({}),
+    });
+    expect(agent.getFullUrl()).toBe('https://original.example.com');
+  });
+
+  it('X-Forwarded-Host takes priority over Forwarded header', async () => {
+    const app = agent.getApp();
+    await app.request('http://localhost/', {
+      method: 'POST',
+      headers: {
+        'Authorization': 'Basic ' + btoa('user:pass'),
+        'Content-Type': 'application/json',
+        'X-Forwarded-Host': 'xfh.example.com',
+        'X-Forwarded-Proto': 'https',
+        'Forwarded': 'host=fwd.example.com;proto=https',
+      },
+      body: JSON.stringify({}),
+    });
+    expect(agent.getFullUrl()).toBe('https://xfh.example.com');
+  });
+
+  it('env var SWML_PROXY_URL_BASE takes priority and is never overridden', async () => {
+    process.env['SWML_PROXY_URL_BASE'] = 'https://env-proxy.example.com';
+    const envAgent = new AgentBase({ name: 'env-test', route: '/', basicAuth: ['user', 'pass'] });
+    envAgent.setPromptText('test');
+    const app = envAgent.getApp();
+    await app.request('http://localhost/', {
+      method: 'POST',
+      headers: {
+        'Authorization': 'Basic ' + btoa('user:pass'),
+        'Content-Type': 'application/json',
+        'X-Forwarded-Host': 'ngrok.example.com',
+        'X-Forwarded-Proto': 'https',
+      },
+      body: JSON.stringify({}),
+    });
+    // Should still use env var, not detected proxy
+    expect(envAgent.getFullUrl()).toBe('https://env-proxy.example.com');
+    delete process.env['SWML_PROXY_URL_BASE'];
+  });
+
+  it('proxy URL is used in rendered SWML webhook URLs', async () => {
+    agent.defineTool({
+      name: 'test_fn',
+      description: 'Test',
+      parameters: {},
+      handler: () => ({ response: 'ok' }),
+    });
+
+    const app = agent.getApp();
+    const res = await app.request('http://localhost/', {
+      method: 'POST',
+      headers: {
+        'Authorization': 'Basic ' + btoa('user:pass'),
+        'Content-Type': 'application/json',
+        'X-Forwarded-Host': 'webhook.example.com',
+        'X-Forwarded-Proto': 'https',
+      },
+      body: JSON.stringify({}),
+    });
+    const swml = await res.json();
+    const webhookUrl = swml.sections.main[1].ai.SWAIG.defaults.web_hook_url;
+    expect(webhookUrl).toContain('webhook.example.com');
+    expect(webhookUrl).toContain('https://');
+  });
+
+  it('no proxy headers leaves getFullUrl unchanged', async () => {
+    const beforeUrl = agent.getFullUrl();
+    const app = agent.getApp();
+    await app.request('http://localhost/', {
+      method: 'POST',
+      headers: {
+        'Authorization': 'Basic ' + btoa('user:pass'),
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({}),
+    });
+    expect(agent.getFullUrl()).toBe(beforeUrl);
+  });
+});

package/tests/SchemaUtils.test.ts

@@ -0,0 +1,106 @@
+import { describe, it, expect } from 'vitest';
+import { SchemaUtils } from '../src/SchemaUtils.js';
+
+describe('SchemaUtils', () => {
+  it('validates a minimal valid SWML document', () => {
+    const validator = new SchemaUtils();
+    const result = validator.validate({
+      version: '1.0.0',
+      sections: { main: [] },
+    });
+    expect(result.valid).toBe(true);
+    expect(result.errors).toHaveLength(0);
+  });
+
+  it('rejects missing version', () => {
+    const validator = new SchemaUtils();
+    const result = validator.validate({ sections: { main: [] } });
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('version'))).toBe(true);
+  });
+
+  it('rejects missing sections', () => {
+    const validator = new SchemaUtils();
+    const result = validator.validate({ version: '1.0.0' });
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('sections'))).toBe(true);
+  });
+
+  it('rejects invalid version', () => {
+    const validator = new SchemaUtils();
+    const result = validator.validate({
+      version: '2.0.0',
+      sections: { main: [] },
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('Invalid version'))).toBe(true);
+  });
+
+  it('rejects missing main section', () => {
+    const validator = new SchemaUtils();
+    const result = validator.validate({
+      version: '1.0.0',
+      sections: { other: [] },
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('main'))).toBe(true);
+  });
+
+  it('validates SWML from JSON string', () => {
+    const validator = new SchemaUtils();
+    const result = validator.validate(JSON.stringify({
+      version: '1.0.0',
+      sections: { main: [{ answer: {} }] },
+    }));
+    expect(result.valid).toBe(true);
+  });
+
+  it('rejects invalid JSON string', () => {
+    const validator = new SchemaUtils();
+    const result = validator.validate('not json');
+    expect(result.valid).toBe(false);
+    expect(result.errors).toContain('Invalid JSON');
+  });
+
+  it('validates AI verb with prompt', () => {
+    const validator = new SchemaUtils();
+    const result = validator.validate({
+      version: '1.0.0',
+      sections: { main: [{ ai: { prompt: { text: 'Hello' } } }] },
+    });
+    expect(result.valid).toBe(true);
+  });
+
+  it('rejects AI verb with empty prompt', () => {
+    const validator = new SchemaUtils();
+    const result = validator.validate({
+      version: '1.0.0',
+      sections: { main: [{ ai: { prompt: {} } }] },
+    });
+    expect(result.valid).toBe(false);
+    expect(result.errors.some(e => e.includes('prompt'))).toBe(true);
+  });
+
+  it('caches validation results', () => {
+    const validator = new SchemaUtils();
+    const doc = JSON.stringify({ version: '1.0.0', sections: { main: [] } });
+    validator.validate(doc);
+    expect(validator.getCacheSize()).toBe(1);
+    validator.validate(doc); // should hit cache
+    expect(validator.getCacheSize()).toBe(1);
+  });
+
+  it('clearCache empties the cache', () => {
+    const validator = new SchemaUtils();
+    validator.validate({ version: '1.0.0', sections: { main: [] } });
+    expect(validator.getCacheSize()).toBe(1);
+    validator.clearCache();
+    expect(validator.getCacheSize()).toBe(0);
+  });
+
+  it('skipValidation always returns valid', () => {
+    const validator = new SchemaUtils({ skipValidation: true });
+    const result = validator.validate({ invalid: true } as any);
+    expect(result.valid).toBe(true);
+  });
+});