Complete Speak integration skill pack with 24 skills covering AI language learning, speech recognition, conversation practice, and education technology. Flagship tier vendor pack.

24 plugin-local skills

MIT License

Claude Code Adapters (declared)

Installation

Open Claude Code and run this command:

/plugin install speak-pack@claude-code-plugins-plus

Use --global to install for all projects, or --project for current project only.

What It Does

> Claude Code skill pack for Speak AI language learning platform integration (24 skills)

Skills (24) plugin-local skills

speak-ci-integration View full skill →

GitHub Actions pipeline for Speak integrations with mocked API tests and audio validation.

ReadWriteEditBash(npm:*)Bash(curl:*)Grep

speak-common-errors View full skill →

Diagnose and fix common Speak API errors: authentication failures, audio format issues, rate limits, and session management problems.

ReadWriteEditBash(npm:*)Bash(curl:*)Grep

Speak Common Errors

Overview

Diagnose and fix common Speak API errors: authentication failures, audio format issues, rate limits, and session management problems.

Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
ffmpeg installed for audio processing

Instructions

Error Code Reference

HTTP	Error Code	Description	Fix
400	`audio_format_invalid`	Audio not WAV 16kHz mono	Convert with ffmpeg
400	`audio_too_short`	Recording < 0.5 seconds	Record longer audio
400	`audio_too_long`	Recording > 60 seconds	Trim to under 60s
400	`language_not_supported`	Invalid language code	Use supported codes
401	`invalid_api_key`	Wrong or expired key	Regenerate at dashboard
403	`quota_exceeded`	Monthly limit reached	Upgrade plan or wait
404	`session_not_found`	Invalid session ID	Start a new session
408	`session_expired`	Session timed out	Sessions expire after 30 min
413	`payload_too_large`	Audio file > 25MB	Compress or trim audio
429	`rate_limit_exceeded`	Too many requests	Wait `Retry-After` seconds

Quick Diagnostic


# Check API key validity
curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer $SPEAK_API_KEY" \
  https://api.speak.com/v1/languages
# 200 = valid, 401 = invalid, 403 = insufficient permissions

# Check audio format
ffprobe -v quiet -print_format json -show_streams recording.wav \
  | python3 -c "import sys,json; s=json.load(sys.stdin)['streams'][0]; print(f'Rate: {s[\"sample_rate\"]}Hz, Channels: {s[\"channels\"]}')"
# Must be: Rate: 16000Hz, Channels: 1

Error Recovery Pattern


async function resilientSpeakCall<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (err: any) {
      const code = err.response?.data?.error?.code;
      if (code === 'audio_format_invalid') {
        // Auto-convert and retry
        throw new Error('Convert audio to WAV 16kHz mono before retrying');
      }
      if (code === 'session_expired') {
        throw


                
                  
                  speak-core-workflow-a
                  View full skill →
                
                
                  Execute Speak primary workflow: AI Conversation Practice with real-time feedback.
                  
                      ReadWriteEditBash(npm:*)Grep
                    
                
                
                  Speak Core Workflow A: AI Conversation Practice
Overview
Primary workflow for Speak: AI-powered conversation practice with real-time pronunciation feedback and adaptive tutoring. Speak uses GPT-4o for conversation generation and OpenAI's Realtime API for speech processing, delivering sub-second response times.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Audio handling capabilities (microphone or pre-recorded files)

Instructions
Step 1: Start a Conversation Session

import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient({
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  language: 'es',
});

// Start a restaurant ordering scenario in Spanish
const session = await client.startConversation({
  scenario: 'ordering-food',
  language: 'es',
  level: 'intermediate',
  nativeLanguage: 'en',
  maxTurns: 10,
  feedbackDetail: 'phoneme', // 'word' or 'phoneme'
});

console.log('Session started:', session.id);
console.log('AI Tutor:', session.firstPrompt.text);
// "Bienvenido al restaurante. Soy tu camarero. Que le gustaria ordenar?"

Step 2: Send Student Responses

// Submit audio for pronunciation scoring
const turn1 = await client.sendTurn(session.id, {
  audioPath: './recordings/student-response-1.wav',
});

console.log('Tutor:', turn1.tutorText);
console.log('Pronunciation:', turn1.pronunciationScore); // 0-100
console.log('Grammar:', turn1.corrections);
// [{original: "yo quiero", suggestion: "quisiera", note: "More polite form for ordering"}]
console.log('Vocabulary:', turn1.vocabularyNotes);
// ["camarero = waiter", "ordenar = to order"]

// Or submit text (skips pronunciation scoring)
const turn2 = await client.sendTurn(session.id, {
  text: 'Quisiera una ensalada y un vaso de agua, por favor.',
});

Step 3: Conversation Loop with Progress Tracking

async function runConversationLesson(
  client: SpeakClient,
  scenario: string,
  language: string,
  level: string,
) {
  const session = await client.startConversation({
    scenario, language, level, nativeLanguage: 'en',
  });

  const turns: TurnResult[] = [];
  let isComplete = false;

  while (!isComplete && turns.length < 10) {
    // Display tutor prompt
    const prompt = turns.length === 0
      ? session.firstPrompt.text
      : turns[turns.length - 1].tutorText;
    console.log(`\nTutor: ${prompt}`);

    // Get student audio (mic input or file)
    const audioPath = await recordStudentAudio();

    // Submit and get feedback
    const turn


                
                  
                  speak-core-workflow-b
                  View full skill →
                
                
                  Execute Speak secondary workflow: Pronunciation Training with phoneme-level analysis.
                  
                      ReadWriteEditBash(npm:*)Grep
                    
                
                
                  Speak Core Workflow B: Pronunciation Training
Overview
Secondary workflow for Speak: detailed pronunciation training with phoneme-level analysis and adaptive practice. Uses OpenAI's speech recognition with Speak's proprietary proficiency graph to identify and drill weak phonemes.
Prerequisites

Completed speak-core-workflow-a
Audio recording capability (WAV 16kHz mono)
ffmpeg installed for audio preprocessing

Instructions
Step 1: Pronunciation Assessment

import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient({
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  language: 'es',
});

// Assess pronunciation of a specific phrase
const result = await client.assessPronunciation({
  audioPath: './recordings/hola-como-estas.wav',
  targetText: 'Hola, como estas?',
  language: 'es',
  detailLevel: 'phoneme',
});

console.log(`Overall score: ${result.score}/100`);
for (const word of result.words) {
  const flag = word.score < 70 ? 'WEAK' : 'OK';
  console.log(`  [${flag}] "${word.text}": ${word.score}/100`);
  if (word.phonemes) {
    for (const p of word.phonemes.filter(p => p.score < 70)) {
      console.log(`    Phoneme "${p.symbol}": ${p.score} — ${p.suggestion}`);
    }
  }
}

Step 2: Adaptive Drill Loop

async function pronunciationDrill(
  client: SpeakClient,
  phrases: string[],
  language: string,
  targetScore: number = 80,
  maxAttempts: number = 3,
) {
  const weakPoints: Map<string, number[]> = new Map();
  const results: DrillResult[] = [];

  for (const phrase of phrases) {
    let bestScore = 0;
    let attempts = 0;

    while (bestScore < targetScore && attempts < maxAttempts) {
      const audioPath = await recordStudentAudio(phrase);
      const result = await client.assessPronunciation({
        audioPath, targetText: phrase, language, detailLevel: 'phoneme',
      });

      bestScore = Math.max(bestScore, result.score);
      attempts++;

      // Track weak phonemes
      for (const word of result.words) {
        for (const p of (word.phonemes || []).filter(p => p.score < 70)) {
          const scores = weakPoints.get(p.symbol) || [];
          scores.push(p.score);
          weakPoints.set(p.symbol, scores);
        }
      }

      if (result.score >= targetScore) {
        console.log(`"${phrase}": PASSED (${result.score}/100, ${attempts} attempts)`);
      } else if (attempts < maxAttempts) {
        console.log(`"${phrase}": ${result.score}/100 — try again`);
      }
    }

    results.push({ phrase, bestScore, attempts });
  }

  return { results, weakPoints };
}

Step 3: Weakness Report
                
                  
                  speak-cost-tuning
                  View full skill →
                
                
                  Optimize Speak API costs through usage monitoring, tier selection, and efficient audio processing.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Cost Tuning
Overview
Optimize Speak API costs through usage monitoring, tier selection, and efficient audio processing.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Step 1: Configuration
Configure cost tuning for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_cost_tuning_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak cost tuning
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

Speak Cost Tuning configured and verified
Production-ready Speak integration
Error handling and monitoring in place

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY


429 Rate Limited
Too many requests
Implement backoff


Connection timeout
Network issue
Check connectivity to api.speak.com


Audio format error
Wrong codec
Convert to WAV 16kHz mono


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
For production checklist, see speak-prod-checklist.
Examples
Basic: Apply cost tuning with default settings for a standard Speak integration.
Production: Configure with monitoring, alerting, and team-specific language learning requirements.
                
              

                
                  
                  speak-data-handling
                  View full skill →
                
                
                  Handle student audio data, assessment records, and learning progress with GDPR/COPPA compliance.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Data Handling
Overview
Handle student audio data, assessment records, and learning progress with GDPR/COPPA compliance.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Step 1: Configuration
Configure data handling for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_data_handling_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak data handling
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

Speak Data Handling configured and verified
Production-ready Speak integration
Error handling and monitoring in place

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY


429 Rate Limited
Too many requests
Implement backoff


Connection timeout
Network issue
Check connectivity to api.speak.com


Audio format error
Wrong codec
Convert to WAV 16kHz mono


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
For production checklist, see speak-prod-checklist.
Examples
Basic: Apply data handling with default settings for a standard Speak integration.
Production: Configure with monitoring, alerting, and team-specific language learning requirements.
                
              

                
                  
                  speak-debug-bundle
                  View full skill →
                
                
                  Collect diagnostic information for Speak API issues: auth verification, audio format validation, session inspection, and network testing.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Debug Bundle
Overview
Collect diagnostic information for Speak API issues: auth verification, audio format validation, session inspection, and network testing.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
ffmpeg installed for audio processing

Instructions
Current State
!node --version 2>/dev/null || echo 'N/A' !ffmpeg -version 2>/dev/null | head -1 || echo 'ffmpeg not installed'
Step 1: Auth Diagnostic

#!/bin/bash
set -euo pipefail
echo "=== Speak Debug Bundle ==="
echo "Time: $(date -u)"

echo -e "\n--- Auth Check ---"
STATUS=$(curl -s -o /dev/null -w "%{http_code}" \
  -H "Authorization: Bearer $SPEAK_API_KEY" \
  https://api.speak.com/v1/languages)
echo "API Key Status: HTTP $STATUS"
[ "$STATUS" = "200" ] && echo "  Auth: OK" || echo "  Auth: FAILED"

echo -e "\n--- Environment ---"
echo "SPEAK_API_KEY set: $([ -n \"${SPEAK_API_KEY:-}\" ] && echo 'yes' || echo 'no')"
echo "SPEAK_APP_ID set: $([ -n \"${SPEAK_APP_ID:-}\" ] && echo 'yes' || echo 'no')"

Step 2: Audio Format Validator

import { execSync } from 'child_process';

function validateAudio(filePath: string): { valid: boolean; issues: string[] } {
  const issues: string[] = [];
  try {
    const info = JSON.parse(execSync(
      `ffprobe -v quiet -print_format json -show_streams "${filePath}"`,
      { encoding: 'utf-8' }
    ));
    const stream = info.streams[0];

    if (stream.codec_name !== 'pcm_s16le') issues.push(`Codec: ${stream.codec_name} (need pcm_s16le)`);
    if (parseInt(stream.sample_rate) !== 16000) issues.push(`Sample rate: ${stream.sample_rate} (need 16000)`);
    if (stream.channels !== 1) issues.push(`Channels: ${stream.channels} (need 1/mono)`);

    const size = parseInt(execSync(`stat -f%z "${filePath}"`, { encoding: 'utf-8' }));
    if (size > 25 * 1024 * 1024) issues.push(`File too large: ${(size/1024/1024).toFixed(1)}MB (max 25MB)`);
    if (size < 1000) issues.push('File too small — may be empty or corrupt');
  } catch (e) {
    issues.push(`Cannot read file: ${e}`);
  }
  return { valid: issues.length === 0, issues };
}

Step 3: Network Connectivity

echo -e "\n--- Network ---"
curl -s -o /dev/null -w "API: HTTP %{http_code} in %{time_total}s\n" \
  -H "Authorization: Bearer $SPEAK_API_KEY" \
  https://api.speak.com/v1/health

curl -s -o /dev/null -w "OpenAI: HTTP %{http_code} in %{time_total}s\n" \
  -H "Autho

                

              

                
                  
                  speak-deploy-integration
                  View full skill →
                
                
                  Deploy Speak language learning features to Vercel, Cloud Run, or containerized environments.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Deploy Integration
Overview
Deploy Speak language learning features to Vercel, Cloud Run, or containerized environments.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Step 1: Configuration
Configure deploy integration for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_deploy_integration_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak deploy integration
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

Speak Deploy Integration configured and verified
Production-ready Speak integration
Error handling and monitoring in place

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY


429 Rate Limited
Too many requests
Implement backoff


Connection timeout
Network issue
Check connectivity to api.speak.com


Audio format error
Wrong codec
Convert to WAV 16kHz mono


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
For production checklist, see speak-prod-checklist.
Examples
Basic: Apply deploy integration with default settings for a standard Speak integration.
Production: Configure with monitoring, alerting, and team-specific language learning requirements.
                
              

                
                  
                  speak-enterprise-rbac
                  View full skill →
                
                
                  Configure Speak for schools and organizations: SSO, teacher/student roles, class management, and usage reporting.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Enterprise RBAC
Overview
Configure Speak for schools and organizations: SSO, teacher/student roles, class management, and usage reporting.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Step 1: Configuration
Configure enterprise rbac for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_enterprise_rbac_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak enterprise rbac
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

Speak Enterprise RBAC configured and verified
Production-ready Speak integration
Error handling and monitoring in place

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY


429 Rate Limited
Too many requests
Implement backoff


Connection timeout
Network issue
Check connectivity to api.speak.com


Audio format error
Wrong codec
Convert to WAV 16kHz mono


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
For production checklist, see speak-prod-checklist.
Examples
Basic: Apply enterprise rbac with default settings for a standard Speak integration.
Production: Configure with monitoring, alerting, and team-specific language learning requirements.
                
              

                
                  
                  speak-hello-world
                  View full skill →
                
                
                  Create your first Speak AI tutoring session with pronunciation feedback.
                  
                      ReadWriteEditBash(npm:*)Bash(node:*)
                    
                
                
                  Speak Hello World
Overview
Create your first AI tutoring session with Speak. Demonstrates conversation practice, pronunciation assessment, and real-time feedback using GPT-4o-powered tutoring.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Microphone access (optional for testing)

Instructions
Step 1: Start a Conversation Session

import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient({
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  language: 'es',
});

// Start a beginner Spanish lesson
const session = await client.startConversation({
  scenario: 'greetings',
  language: 'es',
  level: 'beginner',
  nativeLanguage: 'en',
});

console.log('Session ID:', session.id);
console.log('AI Tutor:', session.firstPrompt.text);
// Output: "Hola! Bienvenido a tu leccion de espanol. Como te llamas?"
console.log('Audio URL:', session.firstPrompt.audioUrl);

Step 2: Send a Student Response

// Submit text response (or audio file for pronunciation scoring)
const turn = await client.sendTurn(session.id, {
  text: 'Hola, me llamo Juan. Mucho gusto.',
  // Or: audioPath: './recordings/response.wav'
});

console.log('Tutor response:', turn.tutorText);
console.log('Pronunciation score:', turn.pronunciationScore); // 0-100
console.log('Grammar corrections:', turn.corrections);
// Output: [{original: "me llamo", suggestion: null, correct: true}]
console.log('Vocabulary notes:', turn.vocabularyNotes);

Step 3: Pronunciation Assessment

// Assess pronunciation of a specific phrase
const assessment = await client.assessPronunciation({
  audioPath: './recordings/hola-como-estas.wav',
  targetText: 'Hola, como estas?',
  language: 'es',
  detailLevel: 'phoneme', // 'word' or 'phoneme'
});

console.log(`Overall score: ${assessment.score}/100`);
for (const word of assessment.words) {
  console.log(`  "${word.text}": ${word.score}/100`);
  if (word.phonemes) {
    for (const p of word.phonemes.filter(p => p.score < 70)) {
      console.log(`    Weak phoneme: ${p.symbol} (${p.score}) - ${p.suggestion}`);
    }
  }
}

Step 4: End Session and Review

const summary = await client.endSession(session.id);
console.log('Session Summary:');
console.log(`  Duration: ${summary.durationMinutes} min`);
console.log(`  Turns: ${summary.totalTurns}`);
console.log(`  Pronunciation: ${summary.avgPronunciationScore}/100`);
console.log(`  Grammar: ${summary.grammarAccuracy}%`);
console.log(`  New voc

                

              

                
                  
                  speak-incident-runbook
                  View full skill →
                
                
                  Incident response for Speak API outages: triage, fallback to offline mode, and recovery procedures.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Incident Runbook
Overview
Incident response for Speak API outages: triage, fallback to offline mode, and recovery procedures.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Step 1: Configuration
Configure incident runbook for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_incident_runbook_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak incident runbook
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// CI test with mocked responses
async function runCITests() {
  const mockClient = new MockSpeakClient();
  await mockClient.assessPronunciation({ audioPath: "test.wav", targetText: "hello", language: "en" });
  console.log("CI tests passed");
}

Step 3: Verification

npm test

Output

Speak Incident Runbook configured and verified
CI pipeline with mocked Speak API tests
Error handling and monitoring in place

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY


429 Rate Limited
Too many requests
Implement backoff


Connection timeout
Network issue
Check connectivity to api.speak.com


Audio format error
Wrong codec
Convert to WAV 16kHz mono


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
For deployment, see speak-deploy-integration.
Examples
Basic: Apply incident runbook with default settings for a standard Speak integration.
Production: Configure with monitoring, alerting, and team-specific language learning requirements.
                
              

                
                  
                  speak-install-auth
                  View full skill →
                
                
                  Set up Speak language learning API integration and authentication.
                  
                      ReadWriteEditBash(npm:*)Bash(pip:*)Grep
                    
                
                
                  Speak Install & Auth
Overview
Set up the Speak language learning platform integration. Speak uses OpenAI's GPT-4o and Realtime API for AI tutoring with real-time pronunciation feedback. Supports 14+ languages including Korean, Spanish, Japanese, French, and Mandarin.
Prerequisites

Node.js 18+ or Python 3.10+
Speak developer account with API access
Microphone for speech input testing

Instructions
Step 1: Install Dependencies

set -euo pipefail
# Core Speak SDK
npm install @speak/language-sdk

# Audio processing dependencies
npm install openai          # OpenAI Realtime API for speech
npm install fluent-ffmpeg   # Audio format conversion
npm install node-record-lpcm16  # Microphone capture

Step 2: Configure Authentication

# Speak API credentials
export SPEAK_API_KEY="your-speak-api-key"
export SPEAK_APP_ID="your-app-id"

# OpenAI key for Realtime API (used by Speak for speech processing)
export OPENAI_API_KEY="your-openai-key"

# Create .env file
cat << 'EOF' >> .env
SPEAK_API_KEY=your-speak-api-key
SPEAK_APP_ID=your-app-id
OPENAI_API_KEY=your-openai-key
EOF

Step 3: Initialize the Client

// src/speak/client.ts
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient({
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  language: 'es', // Target language: es, ko, ja, fr, de, pt, zh, id
});

// Verify connection
async function verifySetup() {
  const languages = await client.getLanguages();
  console.log('Available languages:', languages.map(l => l.code).join(', '));
  const health = await client.health.check();
  console.log('API status:', health.status);
}

verifySetup();

Step 4: Configure Speech Recognition

// OpenAI Realtime API for speech-to-text (used by Speak)
import OpenAI from 'openai';

const openai = new OpenAI();

async function transcribeAudio(audioPath: string): Promise<string> {
  const transcription = await openai.audio.transcriptions.create({
    file: fs.createReadStream(audioPath),
    model: 'whisper-1',
    language: 'es', // Match target language
  });
  return transcription.text;
}

Step 5: Supported Languages

<
                
                  
                  speak-local-dev-loop
                  View full skill →
                
                
                  Configure Speak local development with mocked tutors and audio testing.
                  
                      ReadWriteEditBash(npm:*)Bash(pnpm:*)Grep
                    
                
                
                  Speak Local Dev Loop
Overview
Set up a fast local development workflow for Speak language learning integrations. Includes mock tutor responses for offline development, audio test fixtures, and a debug mode for scoring analysis.
Prerequisites

Completed speak-install-auth setup
Node.js 18+ with npm/pnpm
ffmpeg installed (for audio conversion)

Instructions
Step 1: Project Structure

speak-app/
  src/
    speak/client.ts       # Speak API client
    speak/tutor.ts        # AI tutor conversation manager
    speak/pronunciation.ts # Pronunciation assessment
    speak/audio.ts        # Audio recording and preprocessing
  tests/
    mocks/                # Mock responses for offline dev
    fixtures/             # Sample audio files for testing
    unit/                 # Unit tests with mocked API
    integration/          # Integration tests (needs API key)
  .env.development        # Dev credentials
  .env.test              # Test credentials (mock mode)

Step 2: Mock Tutor for Offline Development

// tests/mocks/mock-speak-client.ts
export class MockSpeakClient {
  async startConversation(config: any) {
    return {
      id: 'mock-session-123',
      firstPrompt: {
        text: 'Hola! Bienvenido. Como te llamas?',
        audioUrl: null,
      },
    };
  }

  async sendTurn(sessionId: string, input: any) {
    return {
      tutorText: 'Muy bien! Tu pronunciacion es buena.',
      pronunciationScore: 85,
      corrections: [],
      vocabularyNotes: ['llamo = I call myself'],
    };
  }

  async assessPronunciation(config: any) {
    return {
      score: 82,
      words: [
        { text: 'Hola', score: 95, phonemes: [] },
        { text: 'como', score: 78, phonemes: [
          { symbol: 'o', score: 65, suggestion: 'Round lips more' }
        ]},
      ],
    };
  }
}

Step 3: Audio Test Fixtures

# Generate test audio files using text-to-speech
# macOS:
say -v "Paulina" "Hola, como estas" -o tests/fixtures/hola-es.wav
# Linux:
espeak -v es "Hola, como estas" -w tests/fixtures/hola-es.wav

# Convert to required format
ffmpeg -i tests/fixtures/hola-es.wav -ar 16000 -ac 1 tests/fixtures/hola-es-16k.wav

Step 4: Development Scripts

{
  "scripts": {
    "dev": "tsx watch src/index.ts",
    "dev:mock": "SPEAK_MOCK_MODE=true tsx watch src/index.ts",
    "test": "vitest run",
    "test:watch": "vitest",
    "lesson:test": "tsx src/test-lesson.ts"
  }
}

Step 5: Debug Mode

// Enable detailed scoring output
const DEBUG = process.env

                

              

                
                  
                  speak-migration-deep-dive
                  View full skill →
                
                
                  Migrate between language learning platforms, import student progress, and transition from legacy speech APIs.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Migration Deep Dive
Overview
Migrate between language learning platforms, import student progress, and transition from legacy speech APIs.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Step 1: Configuration
Configure migration deep dive for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_migration_deep_dive_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak migration deep dive
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

Speak Migration Deep Dive configured and verified
Production-ready Speak integration
Error handling and monitoring in place

Error Handling

Language
Code
Pronunciation
Conversation


Korean
ko
Yes
Yes


Spanish
es
Yes
Yes


Japanese
ja
Yes
Yes


French
fr
Yes
Yes


German
de
Yes
Yes

                
              

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY


429 Rate Limited
Too many requests
Implement backoff


Connection timeout
Network issue
Check connectivity to api.speak.com


Audio format error
Wrong codec
Convert to WAV 16kHz mono


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
For production checklist, see speak-prod-checklist.
Examples
Basic: Apply migration deep dive with default settings for a standard Speak integration.
Production: Configure with monitoring, alerting, and team-specific language learning requirements.

                

              

                
                  
                  speak-multi-env-setup
                  View full skill →
                
                
                  Configure Speak across dev, staging, and production with separate API keys and mock modes.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Multi-Environment Setup
Overview
Configure Speak across dev, staging, and production with separate API keys and mock modes.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Step 1: Configuration
Configure multi env setup for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_multi_env_setup_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak multi-environment setup
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

Speak Multi-Environment Setup configured and verified
Production-ready Speak integration
Error handling and monitoring in place

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY


429 Rate Limited
Too many requests
Implement backoff


Connection timeout
Network issue
Check connectivity to api.speak.com


Audio format error
Wrong codec
Convert to WAV 16kHz mono


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
For production checklist, see speak-prod-checklist.
Examples
Basic: Apply multi env setup with default settings for a standard Speak integration.
Production: Configure with monitoring, alerting, and team-specific language learning requirements.
                
              

                
                  
                  speak-observability
                  View full skill →
                
                
                  Monitor Speak API health, assessment latency, session metrics, and pronunciation score distributions.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Observability
Overview
Monitor Speak API health, assessment latency, session metrics, and pronunciation score distributions.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Step 1: Configuration
Configure observability for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_observability_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak observability
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

Speak Observability configured and verified
Production-ready Speak integration
Error handling and monitoring in place

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY


429 Rate Limited
Too many requests
Implement backoff


Connection timeout
Network issue
Check connectivity to api.speak.com


Audio format error
Wrong codec
Convert to WAV 16kHz mono


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
For production checklist, see speak-prod-checklist.
Examples
Basic: Apply observability with default settings for a standard Speak integration.
Production: Configure with monitoring, alerting, and team-specific language learning requirements.
                
              

                
                  
                  speak-performance-tuning
                  View full skill →
                
                
                  Optimize Speak API latency with audio preprocessing, response caching, and connection pooling.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Performance Tuning
Overview
Optimize Speak API latency with audio preprocessing, response caching, and connection pooling.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Step 1: Configuration
Configure performance tuning for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_performance_tuning_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak performance tuning
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

Speak Performance Tuning configured and verified
Production-ready Speak integration
Error handling and monitoring in place

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY


429 Rate Limited
Too many requests
Implement backoff


Connection timeout
Network issue
Check connectivity to api.speak.com


Audio format error
Wrong codec
Convert to WAV 16kHz mono


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
For production checklist, see speak-prod-checklist.
Examples
Basic: Apply performance tuning with default settings for a standard Speak integration.
Production: Configure with monitoring, alerting, and team-specific language learning requirements.
                
              

                
                  
                  speak-prod-checklist
                  View full skill →
                
                
                  Production readiness checklist for Speak language learning integrations: auth, audio pipeline, monitoring, and compliance.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Production Checklist
Overview
Production readiness checklist for Speak language learning integrations: auth, audio pipeline, monitoring, and compliance.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
ffmpeg installed for audio processing

Instructions
Authentication

[ ] API keys stored in secrets manager
[ ] Key rotation schedule established (90 days)
[ ] Separate keys for dev/staging/production
[ ] Error handling for expired keys

Audio Pipeline

[ ] Audio preprocessor converts to WAV 16kHz mono
[ ] File size validation (< 25MB)
[ ] Duration validation (0.5s - 60s)
[ ] Background noise detection/warning
[ ] Fallback for unsupported audio formats

Rate Limiting & Performance

[ ] Rate-limited client wrapper implemented
[ ] Retry logic with exponential backoff on 429
[ ] Request queue for batch assessments
[ ] Response caching where appropriate

Monitoring & Alerting

[ ] API response time tracking
[ ] Error rate monitoring (target < 1%)
[ ] Rate limit hit tracking
[ ] Assessment score distribution monitoring
[ ] Session completion rate tracking

Compliance

[ ] Student data privacy policy documented
[ ] Audio data retention policy implemented
[ ] COPPA compliance verified (if applicable)
[ ] FERPA compliance verified (if educational)
[ ] GDPR data processing agreement (if EU users)

Verification Script

#!/bin/bash
set -euo pipefail
echo "Speak Production Readiness"
curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" \
  https://api.speak.com/v1/health | jq '.status'
echo "  Auth: PASS"
ffmpeg -version > /dev/null 2>&1 && echo "  ffmpeg: PASS" || echo "  ffmpeg: FAIL"
echo "Checks complete."

Output

Checklist implementation complete
Speak API integration verified
Production-ready patterns applied

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY environment variable


429 Rate Limited
Too many requests
Wait Retry-After seconds, use backoff


Audio format error
Wrong codec/sample rate
Convert to WAV 16kHz mono with ffmpeg


Session expired
Timeout after 30 min
Start a new conversation session


Resources

Speak Webs

                

              

                
                  
                  speak-rate-limits
                  View full skill →
                
                
                  Handle Speak API rate limits with exponential backoff, request queuing, and optimization strategies.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Rate Limits
Overview
Handle Speak API rate limits with exponential backoff, request queuing, and optimization strategies.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Rate Limit Overview

Tier
Assessments/min
Conversations/min
Audio upload/min


Free
10
5
10


Pro
60
30
60


Enterprise
300
150
300


Rate-Limited Client

class RateLimitedSpeakClient {
  private lastRequest = 0;
  private minDelay: number;

  constructor(private client: SpeakClient, requestsPerMinute: number = 60) {
    this.minDelay = 60000 / requestsPerMinute;
  }

  private async throttle() {
    const elapsed = Date.now() - this.lastRequest;
    if (elapsed < this.minDelay) {
      await new Promise(r => setTimeout(r, this.minDelay - elapsed));
    }
    this.lastRequest = Date.now();
  }

  async assessPronunciation(config: PronunciationConfig) {
    await this.throttle();
    return this.retryOn429(() => this.client.assessPronunciation(config));
  }

  private async retryOn429<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
    for (let i = 0; i < maxRetries; i++) {
      try {
        return await fn();
      } catch (err: any) {
        if (err.response?.status === 429 && i < maxRetries - 1) {
          const wait = parseInt(err.response.headers['retry-after'] || String(2 ** i));
          console.log(`Rate limited. Waiting ${wait}s...`);
          await new Promise(r => setTimeout(r, wait * 1000));
          continue;
        }
        throw err;
      }
    }
    throw new Error('Max retries exceeded');
  }
}

Batch Assessment Queue

async function batchAssess(client: RateLimitedSpeakClient, recordings: Recording[]) {
  const results = [];
  for (const rec of recordings) {
    const result = await client.assessPronunciation({
      audioPath: rec.path, targetText: rec.text, language: rec.lang,
    });
    results.push({ ...rec, score: result.score });
    console.log(`Assessed "${rec.text}": ${result.score}/100`);
  }
  return results;
}

Output

Limits implementation complete
Speak API integration verified
Production-ready patterns applied

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY environment variable


429 Rate Limited
Too many requests
Wait
                
              
                
                  
                  speak-reference-architecture
                  View full skill →
                
                
                  Production architecture for Speak language learning apps: client, API gateway, assessment engine, and progress store.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Reference Architecture
Overview
Production architecture for Speak language learning apps: client, API gateway, assessment engine, and progress store.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Step 1: Configuration
Configure reference architecture for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_reference_architecture_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak reference architecture
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

Speak Reference Architecture configured and verified
Production-ready Speak integration
Error handling and monitoring in place

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY


429 Rate Limited
Too many requests
Implement backoff


Connection timeout
Network issue
Check connectivity to api.speak.com


Audio format error
Wrong codec
Convert to WAV 16kHz mono


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
For production checklist, see speak-prod-checklist.
Examples
Basic: Apply reference architecture with default settings for a standard Speak integration.
Production: Configure with monitoring, alerting, and team-specific language learning requirements.
                
              

                
                  
                  speak-sdk-patterns
                  View full skill →
                
                
                  Production patterns for Speak language learning API: conversation sessions, pronunciation assessment, audio preprocessing, and batch operations.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak SDK Patterns
Overview
Production patterns for Speak language learning API: conversation sessions, pronunciation assessment, audio preprocessing, and batch operations.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
ffmpeg installed for audio processing

Instructions
Pattern 1: Conversation Session Manager

class ConversationManager {
  private client: SpeakClient;
  private sessions: Map<string, SessionState> = new Map();

  async startLesson(language: string, scenario: string, level: string) {
    const session = await this.client.startConversation({
      scenario, language, level, nativeLanguage: 'en',
    });
    this.sessions.set(session.id, {
      turns: [], startTime: Date.now(), language,
    });
    return session;
  }

  async submitResponse(sessionId: string, audioPath: string) {
    const turn = await this.client.sendTurn(sessionId, { audioPath });
    this.sessions.get(sessionId)?.turns.push(turn);
    return turn;
  }

  async endAndReport(sessionId: string) {
    const summary = await this.client.endSession(sessionId);
    const state = this.sessions.get(sessionId)!;
    return {
      ...summary,
      duration: (Date.now() - state.startTime) / 1000,
      totalTurns: state.turns.length,
      avgPronunciation: state.turns.reduce((s, t) =>
        s + (t.pronunciationScore || 0), 0) / state.turns.length,
    };
  }
}

Pattern 2: Audio Preprocessor

import { execSync } from 'child_process';

function preprocessAudio(inputPath: string): string {
  const outputPath = inputPath.replace(/\.[^.]+$/, '.processed.wav');
  // Convert to WAV 16kHz mono PCM — required by Speak API
  execSync(
    `ffmpeg -y -i "${inputPath}" -ar 16000 -ac 1 -c:a pcm_s16le "${outputPath}"`,
    { stdio: 'pipe' }
  );
  return outputPath;
}

Pattern 3: Retry with Backoff

async function withRetry<T>(fn: () => Promise<T>, maxRetries = 3): Promise<T> {
  for (let i = 0; i < maxRetries; i++) {
    try {
      return await fn();
    } catch (err: any) {
      if (err.response?.status === 429 && i < maxRetries - 1) {
        const wait = parseInt(err.response.headers['retry-after'] || '5');
        await new Promise(r => setTimeout(r, wait * 1000));
        continue;
      }
      throw err;
    }
  }
  throw new Error('Max retries exceeded');
}

Pattern 4: Progress Tracker

class LearningProgress {
  private history: SessionSummary[] = [];

  addSession(summary: SessionSummary) {
    this.history.push(summary);
  }

  getReport() {
    const recent = this.history.slice(-10);
    return {
      totalSessio

                

              

                
                  
                  speak-security-basics
                  View full skill →
                
                
                  Security best practices for Speak API keys, audio data privacy, student data protection, and COPPA/FERPA compliance.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Security Basics
Overview
Security best practices for Speak API keys, audio data privacy, student data protection, and COPPA/FERPA compliance.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
ffmpeg installed for audio processing

Instructions
API Key Security

# Never commit API keys
echo '.env' >> .gitignore
echo '.env.local' >> .gitignore

# Use secrets manager in production
export SPEAK_API_KEY="$(aws secretsmanager get-secret-value --secret-id speak/api-key --query SecretString --output text)"

Audio Data Privacy

// Speak processes audio on their servers — do NOT store student audio locally
// unless required by your application
class PrivacyAwareClient {
  async assessAndClean(audioPath: string, targetText: string, language: string) {
    try {
      const result = await this.client.assessPronunciation({
        audioPath, targetText, language,
      });
      return result;
    } finally {
      // Delete local audio file after assessment
      fs.unlinkSync(audioPath);
    }
  }
}

Student Data Protection

Never log student audio recordings
Redact student names from API logs
Store assessment scores, not raw audio
Implement data retention policies (delete after N days)
COPPA compliance for students under 13: parental consent required
FERPA compliance for educational institutions: student data agreements

Security Checklist

[ ] API keys in secrets manager, not code
[ ] Audio files deleted after processing
[ ] Student PII not logged
[ ] HTTPS enforced for all API calls
[ ] Rate limiting prevents abuse
[ ] Access logs maintained for audit

Output

Basics implementation complete
Speak API integration verified
Production-ready patterns applied

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY environment variable


429 Rate Limited
Too many requests
Wait Retry-After seconds, use backoff


Audio format error
Wrong codec/sample rate
Convert to WAV 16kHz mono with ffmpeg


Session expired
Timeout after 30 min
Start a new conversation session


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
See 
                
              

                
                  
                  speak-upgrade-migration
                  View full skill →
                
                
                  Upgrade Speak SDK versions, migrate between language learning platforms, and handle API version changes.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Upgrade & Migration
Overview
Upgrade Speak SDK versions, migrate between language learning platforms, and handle API version changes.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Current State
!npm list @speak/language-sdk 2>/dev/null || echo 'Speak SDK not installed'
Step 1: Check Current Version

npm list @speak/language-sdk
npm outdated @speak/language-sdk

Step 2: Upgrade SDK

npm install @speak/language-sdk@latest
npm test  # Run tests to verify compatibility

Step 3: API Version Migration

// Check for deprecated endpoints
const DEPRECATED_ENDPOINTS = [
  '/v1/lessons/start',      // Replaced by /v1/conversations/start
  '/v1/speech/score',       // Replaced by /v1/pronunciation/assess
];

// Migration map
const ENDPOINT_MIGRATION = {
  '/v1/lessons/start': '/v1/conversations/start',
  '/v1/speech/score': '/v1/pronunciation/assess',
};

Step 4: Platform Migration (from Duolingo/Babbel APIs)

// Map learning data between platforms
interface MigrationMapper {
  mapProficiencyLevel(source: string): 'beginner' | 'intermediate' | 'advanced';
  mapLanguageCode(source: string): string;
  mapProgress(source: any): SpeakProgress;
}

const duolingoMapper: MigrationMapper = {
  mapProficiencyLevel(crowns: string) {
    const c = parseInt(crowns);
    if (c < 3) return 'beginner';
    if (c < 6) return 'intermediate';
    return 'advanced';
  },
  mapLanguageCode: (code) => code, // Same ISO codes
  mapProgress: (duo) => ({
    vocabulary: duo.words_learned,
    level: duolingoMapper.mapProficiencyLevel(duo.crowns),
  }),
};

Post-Upgrade Verification

npm test
node -e "const s = require('@speak/language-sdk'); console.log('SDK version:', s.version || 'loaded OK')"

Output

Migration implementation complete
Speak API integration verified
Production-ready patterns applied

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY environment variable


429 Rate Limited
Too many requests
Wait Retry-After seconds, use backoff


Audio format error
Wrong codec/sample rate
Convert to WAV 16kHz mono with ffmpeg


Session expired
Timeout after 30 min
Start
                
              
                
                  
                  speak-webhooks-events
                  View full skill →
                
                
                  Handle Speak lesson completion events, progress webhooks, and achievement notifications.
                  
                      ReadWriteEditBash(npm:*)Bash(curl:*)Grep
                    
                
                
                  Speak Webhooks & Events
Overview
Handle Speak lesson completion events, progress webhooks, and achievement notifications.
Prerequisites

Completed speak-install-auth setup
Valid API credentials configured
Understanding of Speak API patterns

Instructions
Step 1: Configuration
Configure webhooks events for your Speak integration. Speak uses OpenAI's GPT-4o for AI tutoring and Whisper for speech recognition.

// speak_webhooks_events_config.ts
const config = {
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  environment: process.env.NODE_ENV || 'development',
};

Step 2: Implementation

// Core implementation for speak webhooks & events
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient(config);

// Production-ready implementation
async function setup() {
  const health = await client.health.check();
  console.log("Status:", health.status);
  return health;
}

Step 3: Verification

curl -sf -H "Authorization: Bearer $SPEAK_API_KEY" https://api.speak.com/v1/health | jq .

Output

Speak Webhooks & Events configured and verified
Production-ready Speak integration
Error handling and monitoring in place

Error Handling

Error
Cause
Solution


401 Unauthorized
Invalid API key
Verify SPEAK_API_KEY


429 Rate Limited
Too many requests
Implement backoff


Connection timeout
Network issue
Check connectivity to api.speak.com


Audio format error
Wrong codec
Convert to WAV 16kHz mono


Resources

Speak Website
OpenAI Realtime API
Speak GPT-4 Blog

Next Steps
For production checklist, see speak-prod-checklist.
Examples
Basic: Apply webhooks events with default settings for a standard Speak integration.
Production: Configure with monitoring, alerting, and team-specific language learning requirements.
                
              
          
        

      
      
          How It Works
          
import { SpeakClient } from '@speak/language-sdk';

const client = new SpeakClient({
  apiKey: process.env.SPEAK_API_KEY!,
  appId: process.env.SPEAK_APP_ID!,
  language: 'es',
});

// Start conversation practice
const session = await client.startConversation({
  scenario: 'ordering-food',
  language: 'es',
  level: 'intermediate',
});
console.log('Tutor:', session.firstPrompt.text);

// Assess pronunciation
const result = await client.assessPronunciation({
  audioPath: './recording.wav',
  targetText: 'Hola, como estas?',
  language: 'es',
  detailLevel: 'phoneme',
});
console.log(`Score: ${result.score}/100`);

        

      
      

      
      

      
      
  Ready to use speak-pack?
  
    
    
  




      
      
          Related Plugins
          
            
  supabase-pack
  Complete Supabase integration skill pack with 30 skills covering authentication, database, storage, realtime, edge functions, and production operations. Flagship+ tier vendor pack.
  /plugin install supabase-pack@claude-code-plugins-plus
  

  vercel-pack
  Complete Vercel integration skill pack with 30 skills covering deployments, edge functions, preview environments, performance optimization, and production operations. Flagship+ tier vendor pack.
  /plugin install vercel-pack@claude-code-plugins-plus
  

  clay-pack
  Complete Clay integration skill pack with 30 skills covering data enrichment, waterfall workflows, AI agents, and GTM automation. Flagship+ tier vendor pack.
  /plugin install clay-pack@claude-code-plugins-plus
  

  cursor-pack
  Complete Cursor integration skill pack with 30 skills covering AI code editing, composer workflows, codebase indexing, and productivity features. Flagship+ tier vendor pack.
  /plugin install cursor-pack@claude-code-plugins-plus
  

  exa-pack
  Complete Exa integration skill pack with 30 skills covering neural search, semantic retrieval, web search API, and AI-powered discovery. Flagship+ tier vendor pack.
  /plugin install exa-pack@claude-code-plugins-plus
  

  firecrawl-pack
  Complete Firecrawl integration skill pack with 30 skills covering web scraping, crawling, markdown conversion, and LLM-ready data extraction. Flagship+ tier vendor pack.
  /plugin install firecrawl-pack@claude-code-plugins-plus
  

          
        

      
      
          Tags
          
            speaklanguage-learningspeechai-tutoreducationconversationedtech
          
        
    
  

  

    

    
    
        
            
                Agent Skills in Your Inbox
                
                    
                    
                    
                
                No spam, ever. Unsubscribe with one click.
            

            
                
                    Product
                    
                        Explore
                        Skills
                        Cowork
                        Compare
                        Tools
                    
                
                
                    Resources
                    
                        Docs
                        Changelog
                        Collections
                        Playbooks
                        Research
                        Learning
                    
                
                
                    Company
                    
                        Community
                        Hall of Fame
                        GitHub
                    
                
                
                    Legal
                    
                        Privacy
                        Terms
                        Acceptable Use
                    
                
            

            
            

            
                Tons of Skills by Intent Solutions. Open-source plugins, agents and skills for AI coding agents.
                © 2026 Tons of Skills | Intent Solutions

Error	Cause	Solution
401 Unauthorized	Invalid API key	Verify SPEAK_API_KEY
429 Rate Limited	Too many requests	Implement backoff
Connection timeout	Network issue	Check connectivity to api.speak.com
Audio format error	Wrong codec	Convert to WAV 16kHz mono

Language	Code	Pronunciation	Conversation
Korean	ko	Yes	Yes
Spanish	es	Yes	Yes
Japanese	ja	Yes	Yes
French	fr	Yes	Yes
German	de	Yes	Yes

Error	Cause	Solution
401 Unauthorized	Invalid API key	Verify SPEAK_API_KEY environment variable
429 Rate Limited	Too many requests	Wait Retry-After seconds, use backoff
Audio format error	Wrong codec/sample rate	Convert to WAV 16kHz mono with ffmpeg
Session expired	Timeout after 30 min	Start a new conversation session

speak-pack

Installation

What It Does

Skills (24) plugin-local skills

Speak CI Integration

Overview

Prerequisites

Instructions

Step 1: Configuration

Step 2: Implementation

Step 3: Verification

Output

Error Handling

Resources

Next Steps

Examples

Speak Common Errors

Overview

Prerequisites

Instructions

Error Code Reference

Quick Diagnostic

Error Recovery Pattern

Speak Core Workflow A: AI Conversation Practice

Overview

Prerequisites

Instructions

Step 1: Start a Conversation Session

Step 2: Send Student Responses

Step 3: Conversation Loop with Progress Tracking

Speak Core Workflow B: Pronunciation Training

Overview

Prerequisites

Instructions

Step 1: Pronunciation Assessment

Step 2: Adaptive Drill Loop

Step 3: Weakness Report

Speak Cost Tuning

Overview

Prerequisites

Instructions

Step 1: Configuration

Step 2: Implementation

Step 3: Verification

Output

Error Handling

Resources

Next Steps

Examples

Speak Data Handling

Overview

Prerequisites

Instructions

Step 1: Configuration

Step 2: Implementation

Step 3: Verification

Output

Error Handling

Resources

Next Steps

Examples

Speak Debug Bundle

Overview

Prerequisites

Instructions

Current State

Step 1: Auth Diagnostic

Step 2: Audio Format Validator

Step 3: Network Connectivity

Speak Deploy Integration

Overview

Prerequisites

Instructions

Step 1: Configuration

Step 2: Implementation

Step 3: Verification

Output

Error Handling

Resources

Next Steps