@startsimpli/llm 0.4.27 → 0.4.28

package/README.md

@@ -196,7 +196,6 @@ const { text, words } = await speech.transcribe({
 
 | Env | Provider | List price |
 | --- | --- | --- |
-| `GROQ_API_KEY` | Groq `whisper-large-v3-turbo` | $0.04 / audio hour |
 | `OPENAI_API_KEY` | OpenAI `gpt-4o-mini-transcribe` (default; `gpt-4o-transcribe` / `whisper-1` cost 2x) | $0.18 / hour |
 | `ELEVENLABS_API_KEY` | ElevenLabs Scribe (keyterm hints are a billed add-on, so off unless `sendKeyterms`) | $0.22 / hour |
 | `SPEECH_PROVIDER=mock` | deterministic, for tests | — |
@@ -206,8 +205,8 @@ Retryable errors back off and retry; a failure that survives falls through to th
 vendor (`fallback: false` to pin one). Bad audio (`INVALID_REQUEST`) never falls through.
 
 **Add a vendor** — implement `ISpeechProvider` (state `costPerMinuteUsd`) and register it, no
-service edit. An OpenAI-compatible host is a ten-line subclass of `OpenAISpeechProvider`
-(see `providers/groq.ts`):
+service edit. An OpenAI-compatible host is just `OpenAISpeechProvider` with a different
+`name` / `baseUrl` / `defaultModel` / `prices`:
 
 ```ts
 registerSpeechProvider('mine', () => (process.env.MINE_KEY ? new MyProvider(process.env.MINE_KEY) : null));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@startsimpli/llm",
-  "version": "0.4.27",
+  "version": "0.4.28",
   "description": "Generic LLM service infrastructure — provider abstraction, retry logic, JSON extraction",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/__tests__/speech-cost.test.ts

@@ -1,7 +1,7 @@
 import { describe, expect, it, vi } from 'vitest';
 
 import {
-  ElevenLabsSpeechProvider, GroqSpeechProvider, OpenAISpeechProvider, SpeechService, createGroqSpeechProvider,
+  ElevenLabsSpeechProvider, OpenAISpeechProvider, SpeechService,
 } from '../speech';
 import type { ISpeechProvider, TranscribeRequest } from '../speech';
 
@@ -19,23 +19,21 @@ describe('what each vendor costs per audio minute (USD, list price)', () => {
   it('elevenlabs Scribe is $0.22/hour', () => {
     expect(new ElevenLabsSpeechProvider({ apiKey: 'k' }).costPerMinuteUsd()).toBeCloseTo(0.22 / 60);
   });
-  it('groq whisper-large-v3-turbo is $0.04/hour', () => {
-    expect(new GroqSpeechProvider({ apiKey: 'k' }).costPerMinuteUsd()).toBeCloseTo(0.04 / 60);
-  });
 });
 
-describe('groq provider (OpenAI-compatible endpoint)', () => {
-  it('is only built when GROQ_API_KEY is set', () => {
-    expect(createGroqSpeechProvider({})).toBeNull();
-    expect(createGroqSpeechProvider({ GROQ_API_KEY: 'g' })?.name).toBe('groq');
-  });
-  it('posts to Groq with its own default model and reports itself as groq', async () => {
+describe('an OpenAI-compatible host is the OpenAI provider with different options', () => {
+  it('reports its own name, model and price and posts to its own base URL', async () => {
     const f = okJson({ text: ' hi ' });
-    const out = await new GroqSpeechProvider({ apiKey: 'g', fetchImpl: f as never }).transcribe(req);
+    const p = new OpenAISpeechProvider({
+      apiKey: 'k', name: 'selfhosted', baseUrl: 'https://stt.example.com/openai', defaultModel: 'w',
+      prices: { w: 0.001 }, fetchImpl: f as never,
+    });
+    const out = await p.transcribe(req);
     const [url, init] = f.mock.calls[0] as unknown as [string, RequestInit];
-    expect(url).toBe('https://api.groq.com/openai/v1/audio/transcriptions');
-    expect((init.body as FormData).get('model')).toBe('whisper-large-v3-turbo');
-    expect(out).toMatchObject({ text: 'hi', provider: 'groq' });
+    expect(url).toBe('https://stt.example.com/openai/v1/audio/transcriptions');
+    expect((init.body as FormData).get('model')).toBe('w');
+    expect(out).toMatchObject({ text: 'hi', provider: 'selfhosted' });
+    expect(p.costPerMinuteUsd()).toBeCloseTo(0.001);
   });
 });
 

package/src/__tests__/speech.test.ts

@@ -153,7 +153,7 @@ describe('SpeechService', () => {
   });
   it('says what to set when nothing is configured', async () => {
     const s = withProviders(new SpeechService());
-    await expect(s.transcribe(req)).rejects.toThrow(/GROQ_API_KEY, OPENAI_API_KEY or ELEVENLABS_API_KEY/);
+    await expect(s.transcribe(req)).rejects.toThrow(/OPENAI_API_KEY or ELEVENLABS_API_KEY/);
     expect(s.isAvailable()).toBe(false);
   });
   it('SPEECH_LANGUAGE is a default, and a per-call language wins', async () => {

package/src/speech/index.ts

@@ -14,6 +14,5 @@ export type {
 export { ElevenLabsSpeechProvider, createElevenLabsSpeechProvider } from './providers/elevenlabs';
 export { OpenAISpeechProvider, createOpenAISpeechProvider } from './providers/openai';
 export type { OpenAISpeechOptions } from './providers/openai';
-export { GroqSpeechProvider, createGroqSpeechProvider } from './providers/groq';
 export { MockSpeechProvider, setMockSpeechBehavior, resetMockSpeechBehavior } from './providers/mock';
 export { audioExtension, speechHttpError } from './http';

package/src/speech/providers/openai.ts

@@ -5,8 +5,8 @@
  * and equally accurate on our benchmark. Per-word timings are only offered by
  * `whisper-1` (verbose_json), so asking for `timestamps: 'word'` switches model.
  *
- * ANY OpenAI-COMPATIBLE ENDPOINT IS THIS CLASS WITH DIFFERENT OPTIONS (see
- * groq.ts): name, base URL, default model, word-timing model and price table.
+ * ANY OpenAI-COMPATIBLE ENDPOINT IS THIS CLASS WITH DIFFERENT OPTIONS: name, base
+ * URL, default model, word-timing model and price table.
  */
 import type { ISpeechProvider } from '../interface';
 import { assertAudio, audioBlob, speechFetch } from '../http';

package/src/speech/service.ts

@@ -2,7 +2,6 @@ import { LLMProviderError } from '../errors';
 import { ProviderRegistry } from '../providers/registry';
 import type { ISpeechProvider } from './interface';
 import { createElevenLabsSpeechProvider } from './providers/elevenlabs';
-import { createGroqSpeechProvider } from './providers/groq';
 import { MockSpeechProvider } from './providers/mock';
 import { createOpenAISpeechProvider } from './providers/openai';
 import type { SpeechServiceConfig, TranscribeRequest, TranscriptResult } from './types';
@@ -12,7 +11,6 @@ import type { SpeechServiceConfig, TranscribeRequest, TranscriptResult } from '.
  * `registerSpeechProvider('name', factory)` — no edit to `SpeechService`.
  */
 export const speechProviders = new ProviderRegistry<ISpeechProvider>()
-  .register('groq', () => createGroqSpeechProvider())
   .register('openai', () => createOpenAISpeechProvider())
   .register('elevenlabs', () => createElevenLabsSpeechProvider());
 
@@ -76,7 +74,7 @@ export class SpeechService {
     const order = this.order();
     if (!order.length) {
       throw new LLMProviderError(
-        'No speech providers available. Set GROQ_API_KEY, OPENAI_API_KEY or ELEVENLABS_API_KEY.',
+        'No speech providers available. Set OPENAI_API_KEY or ELEVENLABS_API_KEY.',
         'AUTHENTICATION_ERROR', false,
       );
     }

package/src/speech/providers/groq.ts

@@ -1,35 +0,0 @@
-/**
- * Groq-hosted Whisper — the cheapest option we benchmarked ($0.04 per audio hour,
- * about a fifth of ElevenLabs Scribe). Groq speaks the OpenAI transcription API,
- * so this is the OpenAI provider pointed at a different host: that is the whole
- * file, and the template for any other OpenAI-compatible vendor.
- * Env: GROQ_API_KEY.
- */
-import { OpenAISpeechProvider } from './openai';
-import type { OpenAISpeechOptions } from './openai';
-
-const GROQ_PRICES: Record<string, number> = {
-  'whisper-large-v3-turbo': 0.04 / 60,
-  'whisper-large-v3': 0.111 / 60,
-};
-
-export class GroqSpeechProvider extends OpenAISpeechProvider {
-  constructor(options: Pick<OpenAISpeechOptions, 'apiKey' | 'fetchImpl' | 'baseUrl'> = {}) {
-    super({
-      ...options,
-      name: 'groq',
-      baseUrl: options.baseUrl ?? 'https://api.groq.com/openai',
-      defaultModel: 'whisper-large-v3-turbo',
-      // Groq's Whisper models return word timings from verbose_json themselves.
-      wordTimestampModel: 'whisper-large-v3-turbo',
-      prices: GROQ_PRICES,
-      fallbackCostPerMinuteUsd: 0.111 / 60,
-    });
-  }
-}
-
-export function createGroqSpeechProvider(
-  env: Record<string, string | undefined> = typeof process !== 'undefined' ? process.env : {},
-): GroqSpeechProvider | null {
-  return env.GROQ_API_KEY ? new GroqSpeechProvider({ apiKey: env.GROQ_API_KEY }) : null;
-}