signalwire-agents 0.1.0

package/tests/SwaigFunctionResult.test.ts

@@ -0,0 +1,298 @@
+import { describe, it, expect } from 'vitest';
+import { SwaigFunctionResult } from '../src/SwaigFunctionResult.js';
+
+describe('SwaigFunctionResult', () => {
+  it('returns default response when empty', () => {
+    const r = new SwaigFunctionResult();
+    expect(r.toDict()).toEqual({ response: 'Action completed.' });
+  });
+
+  it('stores response from constructor', () => {
+    const r = new SwaigFunctionResult('hello');
+    expect(r.toDict()).toEqual({ response: 'hello' });
+  });
+
+  it('supports setResponse', () => {
+    const r = new SwaigFunctionResult().setResponse('hi');
+    expect(r.toDict()).toEqual({ response: 'hi' });
+  });
+
+  it('supports addAction chaining', () => {
+    const r = new SwaigFunctionResult('ok')
+      .addAction('hangup', true)
+      .addAction('stop', true);
+    const d = r.toDict();
+    expect(d.response).toBe('ok');
+    expect(d.action).toEqual([{ hangup: true }, { stop: true }]);
+  });
+
+  it('supports addActions', () => {
+    const r = new SwaigFunctionResult('ok').addActions([
+      { set_global_data: { k: 'v' } },
+      { play: { url: 'music.mp3' } },
+    ]);
+    expect((r.toDict().action as unknown[]).length).toBe(2);
+  });
+
+  it('includes post_process only when true and actions present', () => {
+    const r1 = new SwaigFunctionResult('hi', true);
+    expect(r1.toDict()).toEqual({ response: 'hi' }); // no actions = no post_process
+
+    const r2 = new SwaigFunctionResult('hi', true).hangup();
+    expect(r2.toDict().post_process).toBe(true);
+
+    const r3 = new SwaigFunctionResult('hi', false).hangup();
+    expect(r3.toDict().post_process).toBeUndefined();
+  });
+
+  it('connect builds correct SWML', () => {
+    const r = new SwaigFunctionResult('transferring').connect('+15551234567');
+    const act = (r.toDict().action as Record<string, unknown>[])[0];
+    expect(act['transfer']).toBe('true');
+    const swml = act['SWML'] as Record<string, unknown>;
+    expect(swml['version']).toBe('1.0.0');
+  });
+
+  it('connect with from address', () => {
+    const r = new SwaigFunctionResult('t').connect('+1555', false, '+1666');
+    const act = (r.toDict().action as Record<string, unknown>[])[0];
+    expect(act['transfer']).toBe('false');
+    const swml = act['SWML'] as Record<string, unknown>;
+    const sections = swml['sections'] as Record<string, unknown[]>;
+    const main = sections['main'][0] as Record<string, Record<string, string>>;
+    expect(main['connect']['from']).toBe('+1666');
+  });
+
+  it('swmlTransfer', () => {
+    const r = new SwaigFunctionResult('ok').swmlTransfer('https://example.com', 'bye', false);
+    const act = (r.toDict().action as Record<string, unknown>[])[0];
+    expect(act['transfer']).toBe('false');
+  });
+
+  it('hangup / stop / hold', () => {
+    const r = new SwaigFunctionResult('bye').hangup().stop().hold(60);
+    const acts = r.toDict().action as Record<string, unknown>[];
+    expect(acts[0]).toEqual({ hangup: true });
+    expect(acts[1]).toEqual({ stop: true });
+    expect(acts[2]).toEqual({ hold: 60 });
+  });
+
+  it('hold clamps timeout', () => {
+    const r = new SwaigFunctionResult().hold(9999);
+    expect((r.toDict().action as Record<string, unknown>[])[0]).toEqual({ hold: 900 });
+  });
+
+  it('waitForUser variants', () => {
+    expect(new SwaigFunctionResult('w').waitForUser().toDict().action)
+      .toEqual([{ wait_for_user: true }]);
+    expect(new SwaigFunctionResult('w').waitForUser({ answerFirst: true }).toDict().action)
+      .toEqual([{ wait_for_user: 'answer_first' }]);
+    expect(new SwaigFunctionResult('w').waitForUser({ timeout: 10 }).toDict().action)
+      .toEqual([{ wait_for_user: 10 }]);
+    expect(new SwaigFunctionResult('w').waitForUser({ enabled: false }).toDict().action)
+      .toEqual([{ wait_for_user: false }]);
+  });
+
+  it('say / playBackgroundFile / stopBackgroundFile', () => {
+    const r = new SwaigFunctionResult('ok')
+      .say('hello')
+      .playBackgroundFile('music.mp3')
+      .playBackgroundFile('bg.mp3', true)
+      .stopBackgroundFile();
+    const acts = r.toDict().action as Record<string, unknown>[];
+    expect(acts[0]).toEqual({ say: 'hello' });
+    expect(acts[1]).toEqual({ playback_bg: 'music.mp3' });
+    expect(acts[2]).toEqual({ playback_bg: { file: 'bg.mp3', wait: true } });
+    expect(acts[3]).toEqual({ stop_playback_bg: true });
+  });
+
+  it('speech hints', () => {
+    const r = new SwaigFunctionResult('ok')
+      .addDynamicHints(['word1', { pattern: 'w', replace: 'W' }])
+      .clearDynamicHints()
+      .setEndOfSpeechTimeout(500)
+      .setSpeechEventTimeout(200);
+    const acts = r.toDict().action as Record<string, unknown>[];
+    expect(acts.length).toBe(4);
+    expect(acts[1]).toEqual({ clear_dynamic_hints: {} });
+    expect(acts[2]).toEqual({ end_of_speech_timeout: 500 });
+    expect(acts[3]).toEqual({ speech_event_timeout: 200 });
+  });
+
+  it('global data / metadata', () => {
+    const r = new SwaigFunctionResult('ok')
+      .updateGlobalData({ key: 'val' })
+      .removeGlobalData(['key'])
+      .setMetadata({ m: 1 })
+      .removeMetadata('m');
+    const acts = r.toDict().action as Record<string, unknown>[];
+    expect(acts[0]).toEqual({ set_global_data: { key: 'val' } });
+    expect(acts[1]).toEqual({ unset_global_data: ['key'] });
+    expect(acts[2]).toEqual({ set_meta_data: { m: 1 } });
+    expect(acts[3]).toEqual({ unset_meta_data: 'm' });
+  });
+
+  it('swmlChangeStep / swmlChangeContext', () => {
+    const r = new SwaigFunctionResult('ok').swmlChangeStep('step2').swmlChangeContext('ctx2');
+    const acts = r.toDict().action as Record<string, unknown>[];
+    expect(acts[0]).toEqual({ change_step: 'step2' });
+    expect(acts[1]).toEqual({ change_context: 'ctx2' });
+  });
+
+  it('swmlUserEvent', () => {
+    const r = new SwaigFunctionResult('ok').swmlUserEvent({ type: 'test', val: 1 });
+    const acts = r.toDict().action as Record<string, unknown>[];
+    expect(acts[0]).toEqual({
+      SWML: {
+        sections: { main: [{ user_event: { event: { type: 'test', val: 1 } } }] },
+        version: '1.0.0',
+      },
+    });
+  });
+
+  it('switchContext simple string', () => {
+    const r = new SwaigFunctionResult('ok').switchContext({ systemPrompt: 'new prompt' });
+    expect((r.toDict().action as Record<string, unknown>[])[0]).toEqual({
+      context_switch: 'new prompt',
+    });
+  });
+
+  it('switchContext advanced object', () => {
+    const r = new SwaigFunctionResult('ok').switchContext({
+      systemPrompt: 'sp',
+      userPrompt: 'up',
+      consolidate: true,
+    });
+    expect((r.toDict().action as Record<string, unknown>[])[0]).toEqual({
+      context_switch: { system_prompt: 'sp', user_prompt: 'up', consolidate: true },
+    });
+  });
+
+  it('toggleFunctions / enableFunctionsOnTimeout / updateSettings', () => {
+    const r = new SwaigFunctionResult('ok')
+      .toggleFunctions([{ function: 'fn1', active: false }])
+      .enableFunctionsOnTimeout()
+      .updateSettings({ temperature: 0.5 });
+    const acts = r.toDict().action as Record<string, unknown>[];
+    expect(acts[0]).toEqual({ toggle_functions: [{ function: 'fn1', active: false }] });
+    expect(acts[1]).toEqual({ functions_on_speaker_timeout: true });
+    expect(acts[2]).toEqual({ settings: { temperature: 0.5 } });
+  });
+
+  it('simulateUserInput / enableExtensiveData / replaceInHistory', () => {
+    const r = new SwaigFunctionResult('ok')
+      .simulateUserInput('hi')
+      .enableExtensiveData()
+      .replaceInHistory('replaced');
+    const acts = r.toDict().action as Record<string, unknown>[];
+    expect(acts[0]).toEqual({ user_input: 'hi' });
+    expect(acts[1]).toEqual({ extensive_data: true });
+    expect(acts[2]).toEqual({ replace_in_history: 'replaced' });
+  });
+
+  it('sendSms', () => {
+    const r = new SwaigFunctionResult('sent').sendSms({
+      toNumber: '+1555',
+      fromNumber: '+1666',
+      body: 'hi',
+    });
+    const acts = r.toDict().action as Record<string, unknown>[];
+    const swml = acts[0]['SWML'] as Record<string, unknown>;
+    expect(swml['version']).toBe('1.0.0');
+  });
+
+  it('sendSms throws without body or media', () => {
+    expect(() => {
+      new SwaigFunctionResult().sendSms({ toNumber: '+1', fromNumber: '+2' });
+    }).toThrow('Either body or media must be provided');
+  });
+
+  it('recordCall / stopRecordCall', () => {
+    const r = new SwaigFunctionResult('ok')
+      .recordCall({ format: 'mp3', stereo: true })
+      .stopRecordCall('ctrl1');
+    expect((r.toDict().action as unknown[]).length).toBe(2);
+  });
+
+  it('tap / stopTap', () => {
+    const r = new SwaigFunctionResult('ok')
+      .tap({ uri: 'wss://example.com' })
+      .stopTap();
+    expect((r.toDict().action as unknown[]).length).toBe(2);
+  });
+
+  it('joinRoom', () => {
+    const r = new SwaigFunctionResult('ok').joinRoom('room1');
+    const acts = r.toDict().action as Record<string, unknown>[];
+    const swml = acts[0]['SWML'] as Record<string, unknown>;
+    const sections = swml['sections'] as Record<string, unknown[]>;
+    expect((sections['main'][0] as Record<string, unknown>)['join_room']).toEqual({ name: 'room1' });
+  });
+
+  it('sipRefer', () => {
+    const r = new SwaigFunctionResult('ok').sipRefer('sip:user@example.com');
+    const acts = r.toDict().action as Record<string, unknown>[];
+    const swml = acts[0]['SWML'] as Record<string, unknown>;
+    const sections = swml['sections'] as Record<string, unknown[]>;
+    expect((sections['main'][0] as Record<string, unknown>)['sip_refer']).toEqual({ to_uri: 'sip:user@example.com' });
+  });
+
+  it('joinConference simple', () => {
+    const r = new SwaigFunctionResult('ok').joinConference('conf1');
+    const acts = r.toDict().action as Record<string, unknown>[];
+    const swml = acts[0]['SWML'] as Record<string, unknown>;
+    const sections = swml['sections'] as Record<string, unknown[]>;
+    expect((sections['main'][0] as Record<string, unknown>)['join_conference']).toBe('conf1');
+  });
+
+  it('joinConference with options', () => {
+    const r = new SwaigFunctionResult('ok').joinConference('conf1', { muted: true });
+    const acts = r.toDict().action as Record<string, unknown>[];
+    const swml = acts[0]['SWML'] as Record<string, unknown>;
+    const sections = swml['sections'] as Record<string, unknown[]>;
+    const params = (sections['main'][0] as Record<string, unknown>)['join_conference'] as Record<string, unknown>;
+    expect(params['name']).toBe('conf1');
+    expect(params['muted']).toBe(true);
+  });
+
+  it('executeRpc', () => {
+    const r = new SwaigFunctionResult('ok').executeRpc({
+      method: 'ai_message',
+      callId: 'call-1',
+      params: { role: 'system', message_text: 'hi' },
+    });
+    expect((r.toDict().action as unknown[]).length).toBe(1);
+  });
+
+  it('rpcDial / rpcAiMessage / rpcAiUnhold', () => {
+    const r = new SwaigFunctionResult('ok')
+      .rpcDial('+1555', '+1666', 'https://example.com/swml')
+      .rpcAiMessage('call-1', 'hello')
+      .rpcAiUnhold('call-1');
+    expect((r.toDict().action as unknown[]).length).toBe(3);
+  });
+
+  it('executeSwml with string', () => {
+    const swml = JSON.stringify({ version: '1.0.0', sections: { main: [] } });
+    const r = new SwaigFunctionResult('ok').executeSwml(swml, true);
+    const acts = r.toDict().action as Record<string, unknown>[];
+    const action = acts[0]['SWML'] as Record<string, unknown>;
+    expect(action['transfer']).toBe('true');
+  });
+
+  it('static payment helpers', () => {
+    const action = SwaigFunctionResult.createPaymentAction('Say', 'Enter card');
+    expect(action).toEqual({ type: 'Say', phrase: 'Enter card' });
+
+    const prompt = SwaigFunctionResult.createPaymentPrompt('payment-card-number', [action]);
+    expect(prompt['for']).toBe('payment-card-number');
+
+    const param = SwaigFunctionResult.createPaymentParameter('k', 'v');
+    expect(param).toEqual({ name: 'k', value: 'v' });
+  });
+
+  it('setPostProcess', () => {
+    const r = new SwaigFunctionResult('hi').setPostProcess(true).hangup();
+    expect(r.toDict().post_process).toBe(true);
+  });
+});

package/tests/cli/mock-data.test.ts

@@ -0,0 +1,94 @@
+import { describe, it, expect } from 'vitest';
+import { generateFakePostData, generateMinimalPostData } from '../../src/cli/mock-data.js';
+
+describe('mock-data', () => {
+  describe('generateFakePostData', () => {
+    it('generates data with defaults', () => {
+      const data = generateFakePostData();
+      expect(data.call_id).toBeDefined();
+      expect(data.call_type).toBe('webrtc');
+      expect(data.call_direction).toBe('inbound');
+      expect(data.caller_id_number).toBe('+15551234567');
+      expect(data.channel_type).toBe('web');
+    });
+
+    it('generates SIP call data', () => {
+      const data = generateFakePostData({ callType: 'sip' });
+      expect(data.call_type).toBe('sip');
+      expect(data.channel_type).toBe('phone');
+      expect(data.sip_headers).toBeDefined();
+    });
+
+    it('respects custom options', () => {
+      const data = generateFakePostData({
+        callType: 'sip',
+        callDirection: 'outbound',
+        fromNumber: '+18005551212',
+        toExtension: 'my-agent',
+      });
+      expect(data.call_type).toBe('sip');
+      expect(data.call_direction).toBe('outbound');
+      expect(data.from).toBe('+18005551212');
+      expect(data.to).toBe('my-agent');
+    });
+
+    it('generates unique call IDs', () => {
+      const data1 = generateFakePostData();
+      const data2 = generateFakePostData();
+      expect(data1.call_id).not.toBe(data2.call_id);
+    });
+
+    it('webrtc calls have no sip_headers', () => {
+      const data = generateFakePostData({ callType: 'webrtc' });
+      expect(data.sip_headers).toBeUndefined();
+    });
+  });
+
+  describe('generateMinimalPostData', () => {
+    it('generates minimal data for function execution', () => {
+      const data = generateMinimalPostData('get_time');
+      expect(data.function).toBe('get_time');
+      expect(data.argument).toEqual({});
+      expect(data.call_id).toBeDefined();
+    });
+
+    it('includes provided arguments', () => {
+      const data = generateMinimalPostData('search', { query: 'test' });
+      expect(data.function).toBe('search');
+      expect(data.argument).toEqual({ query: 'test' });
+    });
+
+    it('generates unique call IDs each time', () => {
+      const data1 = generateMinimalPostData('fn');
+      const data2 = generateMinimalPostData('fn');
+      expect(data1.call_id).not.toBe(data2.call_id);
+    });
+
+    it('accepts callId override', () => {
+      const data = generateMinimalPostData('fn', {}, { callId: 'my-call-id' });
+      expect(data.call_id).toBe('my-call-id');
+    });
+
+    it('accepts overrides', () => {
+      const data = generateMinimalPostData('fn', {}, { overrides: { custom_field: 'custom_value' } });
+      expect(data['custom_field']).toBe('custom_value');
+    });
+  });
+
+  describe('generateFakePostData - extended', () => {
+    it('includes call_state', () => {
+      const data = generateFakePostData({ callState: 'ringing' });
+      expect(data.call_state).toBe('ringing');
+    });
+
+    it('accepts callId override', () => {
+      const data = generateFakePostData({ callId: 'fixed-call-id' });
+      expect(data.call_id).toBe('fixed-call-id');
+    });
+
+    it('applies overrides to post data', () => {
+      const data = generateFakePostData({ overrides: { custom: 'value' } });
+      expect(data['custom']).toBe('value');
+    });
+  });
+});

package/tests/cli/swaig-test.test.ts

@@ -0,0 +1,96 @@
+import { describe, it, expect } from 'vitest';
+import { AgentBase } from '../../src/AgentBase.js';
+import { SwaigFunctionResult } from '../../src/SwaigFunctionResult.js';
+
+describe('agent introspection', () => {
+  function createAgent() {
+    const agent = new AgentBase({ name: 'test-agent', route: '/test' });
+    agent.setPromptText('Hello from test agent');
+    agent.defineTool({
+      name: 'greet',
+      description: 'Say hello',
+      parameters: { name: { type: 'string', description: 'Name' } },
+      handler: (args) => new SwaigFunctionResult('Hello ' + (args['name'] || 'world')),
+    });
+    agent.defineTool({
+      name: 'get_time',
+      description: 'Get current time',
+      parameters: {},
+      handler: () => new SwaigFunctionResult('12:00 PM'),
+    });
+    return agent;
+  }
+
+  it('getRegisteredTools returns all tool info', () => {
+    const agent = createAgent();
+    const tools = agent.getRegisteredTools();
+    expect(tools).toHaveLength(2);
+    expect(tools[0].name).toBe('greet');
+    expect(tools[0].description).toBe('Say hello');
+    expect(tools[0].parameters).toHaveProperty('name');
+    expect(tools[1].name).toBe('get_time');
+  });
+
+  it('getRegisteredTools returns empty for no tools', () => {
+    const agent = new AgentBase({ name: 'empty', route: '/test' });
+    expect(agent.getRegisteredTools()).toHaveLength(0);
+  });
+
+  it('getTool returns a specific SwaigFunction', () => {
+    const agent = createAgent();
+    const tool = agent.getTool('greet');
+    expect(tool).toBeDefined();
+    expect(tool!.name).toBe('greet');
+    expect(tool!.description).toBe('Say hello');
+  });
+
+  it('getTool returns undefined for missing tool', () => {
+    const agent = createAgent();
+    expect(agent.getTool('nonexistent')).toBeUndefined();
+  });
+
+  it('can execute tool via getTool', async () => {
+    const agent = createAgent();
+    const tool = agent.getTool('greet')!;
+    const result = await tool.execute({ name: 'Alice' }, {});
+    expect(result.response).toBe('Hello Alice');
+  });
+
+  it('can execute tool with no args', async () => {
+    const agent = createAgent();
+    const tool = agent.getTool('get_time')!;
+    const result = await tool.execute({}, {});
+    expect(result.response).toBe('12:00 PM');
+  });
+
+  it('renderSwml produces valid SWML with tools', () => {
+    const agent = createAgent();
+    const swml = agent.renderSwml('test-call-id');
+    const parsed = JSON.parse(swml);
+    expect(parsed.version).toBe('1.0.0');
+    expect(parsed.sections.main).toBeDefined();
+    const ai = parsed.sections.main[1].ai;
+    expect(ai.SWAIG.functions).toHaveLength(2);
+  });
+});
+
+describe('agent-loader duck typing', () => {
+  it('AgentBase instances pass duck-type check', () => {
+    const agent = new AgentBase({ name: 'test', route: '/test' });
+    // The duck-type check used by agent-loader
+    expect(typeof (agent as any).renderSwml).toBe('function');
+    expect(typeof (agent as any).defineTool).toBe('function');
+    expect(typeof (agent as any).getPrompt).toBe('function');
+  });
+
+  it('plain objects do not pass duck-type check', () => {
+    const obj = { renderSwml: 'not a function' };
+    expect(typeof obj.renderSwml).not.toBe('function');
+  });
+
+  it('AgentBase class prototype has required methods', () => {
+    expect(typeof AgentBase.prototype.renderSwml).toBe('function');
+    expect(typeof AgentBase.prototype.defineTool).toBe('function');
+    expect(typeof AgentBase.prototype.getPrompt).toBe('function');
+  });
+});