Vercel AI SDK

1
import { experimental_generateSpeech as generateSpeech } from 'ai';
2
import {
3
  smallestai,
4
  DEFAULT_LIGHTNING_MODEL,
5
} from 'smallestai-vercel-provider';
6
7
const { audio } = await generateSpeech({
8
  model: smallestai.speech(DEFAULT_LIGHTNING_MODEL),
9
  text: 'Hello from Smallest AI!',
10
  voice: 'sophia',
11
  language: 'auto',   // 'en', 'hi', 'es', ... — defaults to 'auto'
12
  speed: 1.0,
13
});
14
15
// audio.uint8Array — raw WAV bytes
16
// audio.base64    — base64-encoded audio

1
import { experimental_transcribe as transcribe } from 'ai';
2
import { smallestai } from 'smallestai-vercel-provider';
3
import { readFileSync } from 'fs';
4
5
const { text, segments, durationInSeconds } = await transcribe({
6
  model: smallestai.transcription('pulse'),
7
  audio: readFileSync('recording.wav'),
8
  mediaType: 'audio/wav',
9
});
10
11
console.log(text);

1
// app/api/speak/route.ts
2
import { experimental_generateSpeech as generateSpeech } from 'ai';
3
import { smallestai } from 'smallestai-vercel-provider';
4
5
export const runtime = 'nodejs';
6
7
export async function POST(req: Request) {
8
  const { text, voice } = await req.json();
9
10
  const { audio } = await generateSpeech({
11
    model: smallestai.speech('lightning-v3.1'),
12
    text,
13
    voice: voice || 'sophia',
14
  });
15
16
  return new Response(Buffer.from(audio.uint8Array), {
17
    headers: { 'Content-Type': 'audio/wav' },
18
  });
19
}

1
const res = await fetch('/api/speak', {
2
  method: 'POST',
3
  body: JSON.stringify({ text: 'Hello!', voice: 'sophia' }),
4
});
5
const blob = await res.blob();
6
new Audio(URL.createObjectURL(blob)).play();

1
const { audio } = await generateSpeech({
2
  model: smallestai.speech('lightning-v3.1'),
3
  text: 'Hello!',
4
  voice: 'robert',
5
  providerOptions: {
6
    smallestai: {
7
      sampleRate: 44100,        // 8000 | 16000 | 24000 | 44100
8
      outputFormat: 'mp3',      // pcm | mp3 | wav | ulaw | alaw
9
      similarity: 0.5,          // voice similarity (0–1)
10
      enhancement: 1,           // audio enhancement (0 | 1 | 2)
11
      addWavHeader: false,
12
      saveHistory: false,
13
      pronunciationDicts: ['<dict-id>'],
14
    },
15
  },
16
});

1
const result = await transcribe({
2
  model: smallestai.transcription('pulse'),
3
  audio: audioBuffer,
4
  mediaType: 'audio/wav',
5
  providerOptions: {
6
    smallestai: {
7
      language: 'multi',         // 'en' | 'hi' | 'multi' | 'multi-eu' | 'multi-asian' | 'multi-indic' — see Pulse model card
8
      diarize: true,
9
      emotionDetection: true,
10
      genderDetection: true,
11
      wordTimestamps: true,
12
13
      // Privacy
14
      redactPii: true,           // names, addresses → [FIRSTNAME_1] etc.
15
      redactPci: true,           // card #s, CVV → [CREDITCARDCVV_1] etc.
16
17
      // Formatting
18
      numerals: 'auto',          // 'true' | 'false' | 'auto'
19
      punctuate: true,
20
      capitalize: true,
21
22
      // Async webhook delivery
23
      webhookUrl: 'https://example.com/asr-webhook',
24
      webhookMethod: 'POST',
25
      webhookExtra: 'job_id:abc123',
26
    },
27
  },
28
});

1
import { smallestai } from 'smallestai-vercel-provider';
2
import { readFileSync } from 'fs';
3
4
const stream = smallestai.transcriptionStream('pulse', {
5
  language: 'en',
6
  encoding: 'linear16',
7
  sampleRate: 16000,
8
  wordTimestamps: true,
9
  diarize: true,
10
  redactPii: true,
11
  redactPci: true,
12
  numerals: 'auto',
13
  itnNormalize: true,
14
  sentenceTimestamps: true,
15
  keywords: ['NVIDIA:5', 'Jensen'],
16
});
17
18
await stream.connect();
19
20
// Stream raw PCM s16le @ 16 kHz mono
21
const pcm = readFileSync('audio.s16le');
22
for (let i = 0; i < pcm.length; i += 32 * 1024) {
23
  stream.sendAudio(pcm.subarray(i, i + 32 * 1024));
24
}
25
stream.closeStream(); // server flushes, emits is_last: true, then closes
26
27
let fullTranscript = '';
28
for await (const msg of stream) {
29
  if (!msg.is_final) {
30
    console.log('partial:', msg.transcript);
31
  } else {
32
    console.log('final:', msg.transcript);
33
    fullTranscript += (fullTranscript ? ' ' : '') + (msg.transcript || '');
34
  }
35
  if (msg.is_last) break;
36
}
37
console.log('full transcript:', fullTranscript);

1
import {
2
  smallestai,
3
  SmallestAITranscriptionStream,
4
} from 'smallestai-vercel-provider';
5
6
const stream = smallestai.transcriptionStream('pulse', {
7
  language: 'en', encoding: 'linear16', sampleRate: 16000,
8
  wordTimestamps: true, sentenceTimestamps: true, itnNormalize: true,
9
});
10
11
const { transcript } = await SmallestAITranscriptionStream.transcribeOnce(
12
  stream,
13
  audioBytes,
14
);

1
import { smallestai } from 'smallestai-vercel-provider';
2
import { readFileSync } from 'fs';
3
4
// Create an instant clone
5
const clone = await smallestai.voiceClone.create({
6
  file: readFileSync('my-voice.wav'),
7
  fileName: 'my-voice.wav',
8
  displayName: 'My voice',
9
  description: 'Warm narrator',
10
  language: 'en',
11
});
12
console.log(clone.voiceId); // → "voice_abc123"
13
14
// List all clones in your org
15
const all = await smallestai.voiceClone.list();
16
17
// Use the cloned voice in TTS
18
const { audio } = await generateSpeech({
19
  model: smallestai.speech('lightning-v3.1'),
20
  text: 'Hello in my own voice.',
21
  voice: clone.voiceId,
22
});
23
24
// Delete when done
25
await smallestai.voiceClone.delete(clone.voiceId);

1
let fullTranscript = '';
2
for await (const msg of stream) {
3
  if (msg.is_final && msg.transcript) {
4
    fullTranscript += (fullTranscript ? ' ' : '') + msg.transcript;
5
  }
6
  if (msg.is_last) break;
7
}

1
// app/api/transcribe-stream/route.ts (Next.js, Node runtime)
2
import {
3
  smallestai,
4
  createTranscriptionStreamSSEResponse,
5
} from 'smallestai-vercel-provider';
6
7
export const runtime = 'nodejs';
8
9
export async function POST(req: Request) {
10
  const audio = new Uint8Array(await req.arrayBuffer());
11
  const stream = smallestai.transcriptionStream('pulse', {
12
    language: 'en',
13
    encoding: 'linear16',
14
    sampleRate: 16000,
15
    wordTimestamps: true,
16
    itnNormalize: true,
17
  });
18
  await stream.connect();
19
  for (let i = 0; i < audio.length; i += 32 * 1024) {
20
    stream.sendAudio(audio.subarray(i, i + 32 * 1024));
21
  }
22
  stream.closeStream();
23
  return createTranscriptionStreamSSEResponse(stream, { signal: req.signal });
24
}

1
import { parseTranscriptionStreamSSE } from 'smallestai-vercel-provider';
2
3
const res = await fetch('/api/transcribe-stream', { method: 'POST', body: audioBytes });
4
for await (const msg of parseTranscriptionStreamSSE(res)) {
5
  if (msg.is_final) console.log(msg.transcript);
6
  if (msg.is_last) break;
7
}

1
// Browser code:
2
const stream = smallestai.transcriptionStream('pulse', {
3
  language: 'en',
4
  encoding: 'linear16',
5
  sampleRate: 16000,
6
}, {
7
  signedUrl: async () => {
8
    const res = await fetch('/api/get-stream-url');
9
    return (await res.json()).url; // wss://api.smallest.ai/...
10
  },
11
});
12
await stream.connect();

1
const stream = smallestai.transcriptionStream('pulse', {
2
  language: 'en', encoding: 'linear16', sampleRate: 16000,
3
}, {
4
  apiKey: 'sk_...',
5
  auth: 'query',
6
});

1
const stream = smallestai.transcriptionStream('pulse', {
2
  language: 'en',
3
  encoding: 'linear16',
4
  sampleRate: 16000,
5
  autoReconnect: true,
6
  maxReconnectAttempts: 5,    // default 5
7
  reconnectBackoffMs: 500,    // exponential, capped at 30s
8
});
9
10
for await (const msg of stream) {
11
  if (msg.type === 'reconnected') {
12
    console.log(`recovered after ${msg.attempt} attempt(s)`);
13
    continue;
14
  }
15
  // ... normal transcript handling
16
}