Node.js SDK

1
// Webhook apps (Express/HTTP)
2
import { WebhookResponse } from '@jambonz/sdk/webhook';
3
4
// WebSocket apps
5
import { createEndpoint } from '@jambonz/sdk/websocket';
6
7
// REST API client (mid-call control, outbound calls)
8
import { JambonzClient } from '@jambonz/sdk/client';

1
import express from 'express';
2
import { WebhookResponse } from '@jambonz/sdk/webhook';
3
4
const app = express();
5
app.use(express.json());
6
7
app.post('/incoming', (req, res) => {
8
  const jambonz = new WebhookResponse();
9
  jambonz
10
    .say({ text: 'Hello from jambonz!' })
11
    .gather({
12
      input: ['speech', 'digits'],
13
      actionHook: '/handle-input',
14
      say: { text: 'Press 1 for sales or 2 for support.' },
15
    })
16
    .hangup();
17
18
  res.json(jambonz);
19
});
20
21
app.post('/handle-input', (req, res) => {
22
  const jambonz = new WebhookResponse();
23
  const speech = req.body.speech?.alternatives?.[0]?.transcript;
24
  jambonz.say({ text: `You said: ${speech}` }).hangup();
25
  res.json(jambonz);
26
});
27
28
app.listen(3000);

1
import http from 'http';
2
import { createEndpoint } from '@jambonz/sdk/websocket';
3
4
const server = http.createServer();
5
const makeService = createEndpoint({ server, port: 3000 });
6
7
const svc = makeService({ path: '/' });
8
9
svc.on('session:new', (session) => {
10
  // Bind actionHook handlers first
11
  session.on('/gather-result', (evt) => {
12
    const transcript = evt.speech?.alternatives?.[0]?.transcript || '';
13
    session.say({ text: `You said: ${transcript}` }).hangup().reply();
14
  });
15
16
  // Send initial verbs
17
  session
18
    .say({ text: 'Hello! Say something.' })
19
    .gather({ input: ['speech'], actionHook: '/gather-result', timeout: 10 })
20
    .hangup()
21
    .send();
22
});

1
const makeService = createEndpoint({
2
  server,
3
  port: 3000,
4
  envVars: {
5
    OPENAI_MODEL: {
6
      type: 'string',
7
      description: 'LLM model to use',
8
      default: 'gpt-4.1-mini',
9
    },
10
    SYSTEM_PROMPT: {
11
      type: 'string',
12
      description: 'System prompt',
13
      uiHint: 'textarea',
14
      default: 'You are a helpful assistant.',
15
    },
16
  },
17
});
18
19
// Read values in session handler
20
svc.on('session:new', (session) => {
21
  const model = session.data.env_vars?.OPENAI_MODEL || 'gpt-4.1-mini';
22
  // ...
23
});

1
const svc = makeService({ path: '/' });
2
const audioSvc = makeService.audio({ path: '/audio-stream' });
3
4
svc.on('session:new', (session) => {
5
  session
6
    .say({ text: 'Listening...' })
7
    .listen({
8
      url: '/audio-stream',
9
      sampleRate: 8000,
10
      bidirectionalAudio: { enabled: true, streaming: true, sampleRate: 8000 },
11
    })
12
    .send();
13
});
14
15
audioSvc.on('connection', (stream) => {
16
  stream.on('audio', (pcm) => {
17
    // Process audio — feed to STT, record, etc.
18
  });
19
20
  // Send audio back
21
  stream.sendAudio(pcmBuffer);
22
23
  stream.on('close', () => console.log('Audio stream closed'));
24
});

1
import { JambonzClient } from '@jambonz/sdk/client';
2
3
const client = new JambonzClient({
4
  baseUrl: 'https://api.jambonz.us',
5
  accountSid: 'your-account-sid',
6
  apiKey: 'your-api-key',
7
});
8
9
// Create an outbound call
10
await client.calls.create({
11
  from: '+15085551212',
12
  to: { type: 'phone', number: '+15085551213' },
13
  call_hook: '/incoming',
14
});
15
16
// Mid-call control
17
await client.calls.mute(callSid, 'mute');
18
await client.calls.redirect(callSid, 'https://example.com/new-flow');

1
session.on('/llm-tokens', async (evt) => {
2
  const { tokens, done } = evt;
3
4
  if (tokens) {
5
    // Send tokens as they arrive from the LLM — backpressure is handled automatically
6
    await session.sendTtsTokens(tokens);
7
  }
8
9
  if (done) {
10
    // Signal end of token stream
11
    session.flushTtsTokens();
12
  }
13
});

1
session.on('/tool-call', async (evt) => {
2
  const { tool_call_id, name, arguments: args } = evt;
3
  const result = await handleTool(name, args);
4
  session.sendToolOutput(tool_call_id, result);
5
});

1
// Change the system prompt
2
session.updateAgent({
3
  type: 'update_instructions',
4
  instructions: 'You are now a billing agent.',
5
});
6
7
// Inject context
8
session.updateAgent({
9
  type: 'inject_context',
10
  messages: [{ role: 'user', content: 'Customer: Sarah, Gold tier.' }],
11
});
12
13
// Replace tools
14
session.updateAgent({ type: 'update_tools', tools: [...] });
15
16
// Trigger a new response (with optional interrupt)
17
session.updateAgent({
18
  type: 'generate_reply',
19
  interrupt: true,
20
  user_input: 'Tell the customer about the flash sale.',
21
});

1
session.updateLlm({ instructions: 'Switch to Spanish.' });

1
// Mute/unmute
2
session.injectMute('mute');
3
session.injectMute('unmute');
4
5
// Whisper to one party (e.g., coaching a call center agent)
6
session.injectWhisper({ verb: 'say', text: 'The customer is a VIP.' }, agentCallSid);
7
8
// Control noise isolation mid-call
9
session.injectNoiseIsolation('enable', { vendor: 'krisp', level: 80 });
10
session.injectNoiseIsolation('disable');
11
12
// Control recording
13
session.injectRecord('startCallRecording', { siprecServerURL: 'sip:siprec@recorder.example.com' });
14
session.injectRecord('pauseCallRecording');
15
16
// Pause/resume audio streaming
17
session.injectListenStatus('pause');
18
session.injectListenStatus('resume');
19
20
// Send DTMF
21
session.injectDtmf('1234');
22
23
// Redirect call flow
24
session.injectRedirect('/new-webhook');
25
26
// Tag the call with metadata
27
session.injectTag({ priority: 'high', department: 'billing' });