smoltalk 0.10.0 → 0.11.0

package/dist/transcription/openaiCompat.js

@@ -0,0 +1,22 @@
+import OpenAI from "openai";
+import { OpenAITranscriptionClient } from "./openai.js";
+import { resolveBaseUrl } from "../util/provider.js";
+/**
+ * Generic OpenAI-compatible transcription client. Point it at any provider
+ * exposing an OpenAI-shaped /audio/transcriptions endpoint via
+ * `config.baseUrl.openAiCompat` (or OPENAI_COMPAT_BASE_URL) and
+ * `config.apiKey.openAiCompat` (or OPENAI_COMPAT_API_KEY). Mirrors the chat
+ * `SmolOpenAiCompat` client.
+ */
+export class OpenAiCompatTranscriptionClient extends OpenAITranscriptionClient {
+    makeClient() {
+        const baseURL = resolveBaseUrl("openai-compat", { baseUrl: this.config.baseUrl });
+        if (!baseURL) {
+            throw new Error("openai-compat: base URL required (config.baseUrl.openAiCompat or OPENAI_COMPAT_BASE_URL).");
+        }
+        return new OpenAI({ apiKey: this.config.apiKey, baseURL });
+    }
+    noKeyMessage() {
+        return "No API key provided. Set apiKey.openAiCompat or OPENAI_COMPAT_API_KEY.";
+    }
+}

package/dist/transcription.d.ts

@@ -11,11 +11,14 @@ export type TranscribeOptions = {
     provider?: string;
     modelData?: ModelDataBlob;
     apiKey?: SmolConfig["apiKey"];
+    baseUrl?: SmolConfig["baseUrl"];
     language?: string;
     prompt?: string;
     timestampGranularity?: "segment" | "word";
     maxBytes?: number;
     metadata?: Record<string, unknown>;
+    /** Abort the in-flight provider request when this signal fires. */
+    abortSignal?: AbortSignal;
 };
 export type TranscriptionSegment = {
     start: number;

package/dist/transcription.js

@@ -3,10 +3,16 @@ import { redactSecret } from "./util/redact.js";
 import { getLogger } from "./util/logger.js";
 import { resolveProvider, resolveApiKey } from "./util/provider.js";
 import { OpenAITranscriptionClient } from "./transcription/openai.js";
+import { GroqTranscriptionClient } from "./transcription/groq.js";
+import { GoogleTranscriptionClient } from "./transcription/google.js";
+import { OpenAiCompatTranscriptionClient } from "./transcription/openaiCompat.js";
 export { DEFAULT_TRANSCRIBE_BYTES } from "./transcription/baseTranscriptionClient.js";
 // Checked before the user registry so a registered "openai" can't hijack the built-in.
 const builtinClients = Object.create(null);
 builtinClients["openai"] = OpenAITranscriptionClient;
+builtinClients["groq"] = GroqTranscriptionClient;
+builtinClients["google"] = GoogleTranscriptionClient;
+builtinClients["openai-compat"] = OpenAiCompatTranscriptionClient;
 // Null-prototype so provider names like "toString"/"__proto__" can't collide
 // with Object.prototype or pollute the registry.
 const registered = Object.create(null);

package/dist/types.d.ts

@@ -30,6 +30,7 @@ export type SmolConfig = {
         deepInfra?: string;
         liteLlm?: string;
         openAiCompat?: string;
+        groq?: string;
         /** Arbitrary provider names, for keys targeting a custom-registered provider
          *  (e.g. registerProvider("acme", ...)), keyed by the exact registered name. */
         [provider: string]: string | undefined;

package/dist/util/audioMime.d.ts

@@ -7,3 +7,20 @@ export declare function transcriptionAudioType(mime: string): TranscriptionAudio
 export declare function chatAudioFormat(mime: string): "mp3" | "wav" | null;
 export declare const SPEECH_FORMAT_TO_MIME: Record<SpeakFormat, string>;
 export declare function isSpeakFormat(value: string): value is SpeakFormat;
+/**
+ * Translate a canonical/alias audio MIME to the wire value Google expects.
+ * Google documents MP3 as `audio/mp3`, whereas this repo canonicalizes it to
+ * `audio/mpeg`; everything else passes through canonicalized.
+ */
+export declare function googleAudioWireMime(mimeType: string): string;
+export type PcmWavOptions = {
+    sampleRateHz: number;
+    channels: number;
+    bitsPerSample: number;
+};
+/**
+ * Wrap raw signed-integer little-endian PCM in a 44-byte RIFF/WAVE header so it
+ * becomes a directly-playable .wav. Pure function, no dependency. Used for
+ * Gemini TTS output, which is only ever raw PCM.
+ */
+export declare function pcmToWav(pcm: Uint8Array, opts: PcmWavOptions): Uint8Array;

package/dist/util/audioMime.js

@@ -1,4 +1,4 @@
-import { audioFormatForMime } from "./mime.js";
+import { audioFormatForMime, canonicalizeMime } from "./mime.js";
 export function transcriptionAudioType(mime) {
     const format = audioFormatForMime(mime);
     if (format === null) {
@@ -31,3 +31,44 @@ export const SPEECH_FORMAT_TO_MIME = {
 export function isSpeakFormat(value) {
     return Object.hasOwn(SPEECH_FORMAT_TO_MIME, value);
 }
+/**
+ * Translate a canonical/alias audio MIME to the wire value Google expects.
+ * Google documents MP3 as `audio/mp3`, whereas this repo canonicalizes it to
+ * `audio/mpeg`; everything else passes through canonicalized.
+ */
+export function googleAudioWireMime(mimeType) {
+    const format = audioFormatForMime(mimeType);
+    const canonical = format?.mimeType ?? canonicalizeMime(mimeType);
+    return canonical === "audio/mpeg" ? "audio/mp3" : canonical;
+}
+/**
+ * Wrap raw signed-integer little-endian PCM in a 44-byte RIFF/WAVE header so it
+ * becomes a directly-playable .wav. Pure function, no dependency. Used for
+ * Gemini TTS output, which is only ever raw PCM.
+ */
+export function pcmToWav(pcm, opts) {
+    const { sampleRateHz, channels, bitsPerSample } = opts;
+    const blockAlign = (channels * bitsPerSample) / 8;
+    const byteRate = sampleRateHz * blockAlign;
+    const out = new Uint8Array(44 + pcm.length);
+    const view = new DataView(out.buffer);
+    const writeAscii = (offset, s) => {
+        for (let i = 0; i < s.length; i++)
+            view.setUint8(offset + i, s.charCodeAt(i));
+    };
+    writeAscii(0, "RIFF");
+    view.setUint32(4, 36 + pcm.length, true);
+    writeAscii(8, "WAVE");
+    writeAscii(12, "fmt ");
+    view.setUint32(16, 16, true); // PCM fmt chunk size
+    view.setUint16(20, 1, true); // audio format = PCM
+    view.setUint16(22, channels, true);
+    view.setUint32(24, sampleRateHz, true);
+    view.setUint32(28, byteRate, true);
+    view.setUint16(32, blockAlign, true);
+    view.setUint16(34, bitsPerSample, true);
+    writeAscii(36, "data");
+    view.setUint32(40, pcm.length, true);
+    out.set(pcm, 44);
+    return out;
+}

package/dist/util/googleAudioUsage.d.ts

@@ -0,0 +1,14 @@
+import type { GenerateContentResponseUsageMetadata } from "@google/genai";
+import type { TokenUsage } from "../types/tokenUsage.js";
+export type GoogleAudioDirection = "input" | "output";
+/**
+ * Normalize Gemini's usage metadata into smoltalk's TokenUsage, separating the
+ * audio bucket for the given direction so the token-priced cost engine can bill
+ * it at the audio rate. STT sets audioDirection "input" (audio prompt tokens);
+ * TTS sets "output" (audio candidate tokens).
+ *
+ * Thinking tokens (`thoughtsTokenCount`) are reported separately from
+ * `candidatesTokenCount` and are always text — they go into the text-output
+ * bucket, never the audio-output bucket.
+ */
+export declare function normalizeGoogleAudioUsage(metadata: GenerateContentResponseUsageMetadata | undefined, audioDirection: GoogleAudioDirection): TokenUsage | undefined;

package/dist/util/googleAudioUsage.js

@@ -0,0 +1,52 @@
+function modalityTokens(details, modality) {
+    return (details ?? [])
+        // `modality` is a MediaModality enum; compare by its string value.
+        .filter((detail) => String(detail.modality) === modality)
+        .reduce((sum, detail) => sum + (detail.tokenCount ?? 0), 0);
+}
+/**
+ * Normalize Gemini's usage metadata into smoltalk's TokenUsage, separating the
+ * audio bucket for the given direction so the token-priced cost engine can bill
+ * it at the audio rate. STT sets audioDirection "input" (audio prompt tokens);
+ * TTS sets "output" (audio candidate tokens).
+ *
+ * Thinking tokens (`thoughtsTokenCount`) are reported separately from
+ * `candidatesTokenCount` and are always text — they go into the text-output
+ * bucket, never the audio-output bucket.
+ */
+export function normalizeGoogleAudioUsage(metadata, audioDirection) {
+    if (metadata === undefined) {
+        return undefined;
+    }
+    const prompt = metadata.promptTokenCount ?? 0;
+    const candidates = metadata.candidatesTokenCount ?? 0;
+    const thoughts = metadata.thoughtsTokenCount ?? 0;
+    if (audioDirection === "input") {
+        const audioIn = modalityTokens(metadata.promptTokensDetails, "AUDIO");
+        const usage = {
+            inputTokens: Math.max(0, prompt - audioIn),
+            outputTokens: candidates + thoughts,
+        };
+        if (audioIn > 0)
+            usage.inputAudioTokens = audioIn;
+        if (metadata.totalTokenCount !== undefined)
+            usage.totalTokens = metadata.totalTokenCount;
+        return usage;
+    }
+    // Output (TTS): split the audio bucket out of candidate tokens. Only assume
+    // "all candidates are audio" when the details array is missing/empty; when it
+    // is present, trust its AUDIO total even if that total is 0 (otherwise
+    // purely-text candidate tokens would be mispriced at the audio rate).
+    const details = metadata.candidatesTokensDetails;
+    const detailsPresent = Array.isArray(details) && details.length > 0;
+    const audioOut = detailsPresent ? modalityTokens(details, "AUDIO") : candidates;
+    const usage = {
+        inputTokens: prompt,
+        outputTokens: Math.max(0, candidates - audioOut) + thoughts,
+    };
+    if (audioOut > 0)
+        usage.outputAudioTokens = audioOut;
+    if (metadata.totalTokenCount !== undefined)
+        usage.totalTokens = metadata.totalTokenCount;
+    return usage;
+}

package/dist/util/mime.js

@@ -11,6 +11,8 @@ export const AUDIO_FORMATS = [
     { extension: "ogg", mimeType: "audio/ogg", aliasMimeTypes: [], aliasExtensions: [] },
     { extension: "flac", mimeType: "audio/flac", aliasMimeTypes: [], aliasExtensions: [] },
     { extension: "webm", mimeType: "audio/webm", aliasMimeTypes: [], aliasExtensions: [] },
+    { extension: "aac", mimeType: "audio/aac", aliasMimeTypes: [], aliasExtensions: [] },
+    { extension: "aiff", mimeType: "audio/aiff", aliasMimeTypes: ["audio/x-aiff"], aliasExtensions: ["aif"] },
 ];
 const IMAGE_AND_DOCUMENT_EXT_TO_MIME = {
     ".png": "image/png",

package/dist/util/provider.d.ts

@@ -19,6 +19,7 @@ type NestedKeyConfig = {
         deepInfra?: string;
         liteLlm?: string;
         openAiCompat?: string;
+        groq?: string;
         /** Arbitrary provider names, for keys targeting a custom-registered provider. */
         [provider: string]: string | undefined;
     };

package/dist/util/provider.js

@@ -37,6 +37,8 @@ export function resolveApiKey(provider, config) {
             return k?.liteLlm || process.env.LITELLM_API_KEY;
         case "openai-compat":
             return k?.openAiCompat || process.env.OPENAI_COMPAT_API_KEY;
+        case "groq":
+            return k?.groq || process.env.GROQ_API_KEY;
         default:
             return config.apiKey?.[provider];
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "files": [
@@ -38,6 +38,14 @@
   "devDependencies": {
     "tsx": "^4.19.2"
   },
+  "peerDependencies": {
+    "smoltalk-llama-cpp": ">=0.2.0 <1.0.0"
+  },
+  "peerDependenciesMeta": {
+    "smoltalk-llama-cpp": {
+      "optional": true
+    }
+  },
   "scripts": {
     "test": "vitest --exclude=**/*.live.test.ts",
     "test:live": "vitest run lib/clients/*.live.test.ts lib/embed/*.live.test.ts lib/image/*.live.test.ts",