smoltalk 0.8.4 → 0.10.0

package/dist/models.js

@@ -17,20 +17,35 @@ export const ProviderSchema = z.enum(providers);
 export const speechToTextModels = [
     {
         type: "speech-to-text",
-        modelName: "whisper-web",
+        modelName: "whisper-1",
         perMinuteCost: 0.006,
         provider: "openai",
+        supportedMimeTypes: [
+            "audio/flac", "audio/mpeg", "audio/mp4", "audio/m4a", "audio/ogg",
+            "audio/wav", "audio/webm",
+        ],
+        maxBytes: 25 * 1024 * 1024,
+    },
+];
+export const textToSpeechModels = [
+    {
+        type: "text-to-speech",
+        modelName: "tts-1",
+        perCharacterCost: 0.000015,
+        provider: "openai",
+        maxInputChars: 4096,
+        speedRange: { min: 0.25, max: 4 },
+        formats: ["mp3", "opus", "aac", "flac", "wav", "pcm"],
+    },
+    {
+        type: "text-to-speech",
+        modelName: "tts-1-hd",
+        perCharacterCost: 0.00003,
+        provider: "openai",
+        maxInputChars: 4096,
+        speedRange: { min: 0.25, max: 4 },
+        formats: ["mp3", "opus", "aac", "flac", "wav", "pcm"],
     },
-    // not a speech to text model?
-    /* {
-      type: "speech-to-text",
-      modelName: "gpt-4o-audio-preview",
-      description:
-        "This is a preview release of the GPT-4o Audio models. These models accept audio inputs and outputs, and can be used in the Chat Completions REST API. Learn more. The knowledge cutoff for GPT-4o Audio models is October, 2023.",
-      inputTokenCost: 2.5,
-      outputTokenCost: 10,
-      provider: "openai",
-    }, */
 ];
 export const textModels = [
     {
@@ -771,16 +786,16 @@ export const textModels = [
     {
         type: "text",
         modelName: "gpt-5.6-terra",
-        description: "GPT-5.6 Terra balances capability and cost — competitive with GPT-5.5 at roughly half the price. 1M context window. Standard pricing for ≤272K tokens, 2x input/1.5x output for >272K. Knowledge cutoff: February 2026.",
+        description: "GPT-5.6 Terra balances capability and cost. 1M context window. Standard pricing for ≤272K tokens, 2x input/1.5x output for >272K. Reflects the July 30, 2026 price cut. Knowledge cutoff: February 2026.",
         maxInputTokens: 1050000,
         maxOutputTokens: 128000,
-        inputTokenCost: 2.5,
-        cachedInputTokenCost: 0.25,
-        outputTokenCost: 15,
+        inputTokenCost: 2,
+        cachedInputTokenCost: 0.2,
+        outputTokenCost: 12,
         longContext: {
-            inputTokenCost: 5,
-            cachedInputTokenCost: 0.5,
-            outputTokenCost: 22.5,
+            inputTokenCost: 4,
+            cachedInputTokenCost: 0.4,
+            outputTokenCost: 18,
             thresholdTokens: 200000,
         },
         reasoning: {
@@ -806,16 +821,16 @@ export const textModels = [
     {
         type: "text",
         modelName: "gpt-5.6-luna",
-        description: "GPT-5.6 Luna is the fast, most affordable member of the GPT-5.6 family. 1M context window. Standard pricing for ≤272K tokens, 2x input/1.5x output for >272K. Knowledge cutoff: February 2026.",
+        description: "GPT-5.6 Luna is the fast, most affordable member of the GPT-5.6 family. 1M context window. Standard pricing for ≤272K tokens, 2x input/1.5x output for >272K. Reflects the July 30, 2026 price cut (input/output down ~80%). Knowledge cutoff: February 2026.",
         maxInputTokens: 1050000,
         maxOutputTokens: 128000,
-        inputTokenCost: 1,
-        cachedInputTokenCost: 0.1,
-        outputTokenCost: 6,
+        inputTokenCost: 0.2,
+        cachedInputTokenCost: 0.02,
+        outputTokenCost: 1.2,
         longContext: {
-            inputTokenCost: 2,
-            cachedInputTokenCost: 0.2,
-            outputTokenCost: 9,
+            inputTokenCost: 0.4,
+            cachedInputTokenCost: 0.04,
+            outputTokenCost: 1.8,
             thresholdTokens: 200000,
         },
         reasoning: {
@@ -903,10 +918,40 @@ export const textModels = [
         disabled: true,
         provider: "google",
     },
+    {
+        type: "text",
+        modelName: "gemini-3.6-flash",
+        description: "Latest Gemini 3.6 Flash model (GA July 21, 2026). Supersedes Gemini 3.5 Flash with better token efficiency and agentic planning at a lower output price ($7.50 vs $9.00/1M). 1M context window, 64K output. Context caching: $0.15/1M read.",
+        maxInputTokens: 1048576,
+        maxOutputTokens: 65536,
+        inputTokenCost: 1.5,
+        cachedInputTokenCost: 0.15,
+        outputTokenCost: 7.5,
+        inputAudioTokenCost: 1.5,
+        reasoning: {
+            levels: ["minimal", "low", "medium", "high"],
+            defaultLevel: "high",
+            canDisable: false,
+            outputsThinking: true,
+            outputsSignatures: true,
+        },
+        modalities: {
+            input: ["text", "image", "video", "audio", "pdf"],
+            output: ["text"],
+        },
+        knowledge: "2026-03",
+        releaseDate: "2026-07-21",
+        lastUpdated: "2026-07-21",
+        family: "gemini-flash",
+        openWeights: false,
+        structuredOutput: true,
+        temperatureSupported: true,
+        provider: "google",
+    },
     {
         type: "text",
         modelName: "gemini-3.5-flash",
-        description: "Latest Gemini 3.5 Flash model (GA May 2026). Outperforms Gemini 3.1 Pro on coding and agentic suites at 4x the speed. 1M context window, 64K output. Context caching: $0.15/1M read.",
+        description: "Gemini 3.5 Flash (GA May 2026). Superseded by gemini-3.6-flash. Outperforms Gemini 3.1 Pro on coding and agentic suites at 4x the speed. 1M context window, 64K output. Context caching: $0.15/1M read.",
         maxInputTokens: 1048576,
         maxOutputTokens: 65536,
         inputTokenCost: 1.5,
@@ -964,10 +1009,40 @@ export const textModels = [
         temperatureSupported: true,
         provider: "google",
     },
+    {
+        type: "text",
+        modelName: "gemini-3.5-flash-lite",
+        description: "Most cost-effective Gemini model (GA July 21, 2026). Supersedes gemini-3.1-flash-lite. Built for high-volume, low-reasoning work (search, document processing, translation). Thinking support, 1M context window, 64K output.",
+        maxInputTokens: 1048576,
+        maxOutputTokens: 65536,
+        inputTokenCost: 0.3,
+        cachedInputTokenCost: 0.03,
+        outputTokenCost: 2.5,
+        inputAudioTokenCost: 0.5,
+        reasoning: {
+            levels: ["minimal", "low", "medium", "high"],
+            defaultLevel: "minimal",
+            canDisable: false,
+            outputsThinking: true,
+            outputsSignatures: true,
+        },
+        modalities: {
+            input: ["text", "image", "video", "audio", "pdf"],
+            output: ["text"],
+        },
+        knowledge: "2025-01",
+        releaseDate: "2026-07-21",
+        lastUpdated: "2026-07-21",
+        family: "gemini-flash-lite",
+        openWeights: false,
+        structuredOutput: true,
+        temperatureSupported: true,
+        provider: "google",
+    },
     {
         type: "text",
         modelName: "gemini-3.1-flash-lite",
-        description: "Most cost-effective Gemini 3.1 model (GA). Thinking support, 1M context window, 64K output. 2.5x faster TTFA and 45% faster output than 2.5 Flash.",
+        description: "Cost-effective Gemini 3.1 model (GA). Superseded by gemini-3.5-flash-lite. Thinking support, 1M context window, 64K output. 2.5x faster TTFA and 45% faster output than 2.5 Flash.",
         maxInputTokens: 1048576,
         maxOutputTokens: 65536,
         inputTokenCost: 0.25,
@@ -1549,6 +1624,19 @@ export const textModels = [
         temperatureSupported: false,
         provider: "openai-responses",
     },
+    {
+        type: "text",
+        modelName: "gpt-audio-1.5",
+        description: "OpenAI GA audio chat model (Chat Completions). Text+audio in, text+audio out.",
+        provider: "openai",
+        modalities: { input: ["text", "audio"], output: ["text", "audio"] },
+        inputTokenCost: 2.5,
+        outputTokenCost: 10,
+        inputAudioTokenCost: 32,
+        outputAudioTokenCost: 64,
+        maxInputTokens: 128000,
+        maxOutputTokens: 16384,
+    },
 ];
 export const imageModels = [
     {
@@ -1730,7 +1818,7 @@ export const hostedTools = [
         category: "maps_grounding",
         description: "Grounding with Google Maps (Gemini 3 only).",
         providerToolId: "google_maps",
-        models: ["gemini-3-pro-preview", "gemini-3.1-pro-preview", "gemini-3-flash-preview", "gemini-3.5-flash", "gemini-3.1-flash-lite"],
+        models: ["gemini-3-pro-preview", "gemini-3.1-pro-preview", "gemini-3-flash-preview", "gemini-3.5-flash", "gemini-3.6-flash", "gemini-3.1-flash-lite", "gemini-3.5-flash-lite"],
         pricing: { unit: "per_call", note: "Gemini 3 family only; see Google pricing." },
     },
     {
@@ -1765,6 +1853,7 @@ function baselineModels() {
         ...textModels,
         ...imageModels,
         ...speechToTextModels,
+        ...textToSpeechModels,
         ...registeredTextModels,
         ...embeddingsModels,
     ];
@@ -1790,13 +1879,28 @@ export function getAllModels(requestData) {
 export function getModel(modelName, requestData) {
     return getAllModels(requestData).find((model) => model.modelName === modelName);
 }
+/**
+ * Like `getModel`, but also matches on `provider`. Use this whenever a
+ * modelName may collide across providers (the merge key everywhere else in
+ * this module is `provider:modelName`) — plain `getModel` returns whichever
+ * matching entry comes first and can silently pick the wrong provider.
+ */
+export function getModelForProvider(provider, modelName, requestData) {
+    return getAllModels(requestData).find((model) => model.modelName === modelName && model.provider === provider);
+}
 /**
  * Whether a model is known to accept the given input modality ("image", "pdf", …).
  * Returns undefined when the model is unknown or carries no `modalities` data —
  * callers should treat undefined as "don't gate".
  */
-export function modelSupportsInputModality(modelName, modality, requestData) {
-    const model = getModel(modelName, requestData);
+export function modelSupportsInputModality(modelName, modality, requestData, provider) {
+    let model;
+    if (provider !== undefined) {
+        model = getModelForProvider(provider, modelName, requestData);
+    }
+    else {
+        model = getModel(modelName, requestData);
+    }
     if (!model || model.type !== "text") {
         return undefined;
     }
@@ -1868,6 +1972,9 @@ export function isTextModel(model) {
 export function isSpeechToTextModel(model) {
     return model.type === "speech-to-text";
 }
+export function isTextToSpeechModel(model) {
+    return model.type === "text-to-speech";
+}
 export function isEmbeddingsModel(model) {
     return model.type === "embeddings";
 }

package/dist/speech/baseSpeechClient.d.ts

@@ -0,0 +1,31 @@
+import type { ModelDataBlob } from "../modelData.js";
+import { Result } from "../types/result.js";
+import type { SpeechResult } from "../speech.js";
+export type SpeechClientConfig = {
+    model: string;
+    /** Resolved provider name. */
+    provider: string;
+    /** Resolved API key; empty string when none was found. */
+    apiKey: string;
+    voice: string;
+    modelData?: ModelDataBlob;
+    /** Output format; provider-specific vocabulary (OpenAI: mp3/opus/aac/flac/wav/pcm). */
+    format?: string;
+    speed?: number;
+    metadata?: Record<string, unknown>;
+};
+/**
+ * Shared TTS behavior, mirroring BaseClient for text generation: the public
+ * speak() template method owns model-data-driven validation (char cap, speed
+ * range, format list), cost, and the single redacting/logging exception
+ * boundary. Subclasses implement only _speak(): SDK call + response mapping.
+ * A model with no registry entry skips validation — the provider is then the
+ * authority, matching how cost is silently omitted for unknown models.
+ */
+export declare abstract class BaseSpeechClient {
+    protected config: SpeechClientConfig;
+    constructor(config: SpeechClientConfig);
+    speak(text: string): Promise<Result<SpeechResult>>;
+    /** Provider hook: SDK call + response mapping only; validation and cost live in the base. */
+    protected abstract _speak(text: string): Promise<Result<SpeechResult>>;
+}

package/dist/speech/baseSpeechClient.js

@@ -0,0 +1,98 @@
+import { getModelForProvider, isTextToSpeechModel, } from "../models.js";
+import { calculateSpeechCost } from "../model.js";
+import { failure } from "../types/result.js";
+import { redactSecret } from "../util/redact.js";
+import { getLogger } from "../util/logger.js";
+/** Validate the declarative TTS constraint block once before consuming it. */
+function speechConstraintError(model) {
+    const maxInputChars = model.maxInputChars;
+    if (maxInputChars !== undefined &&
+        (typeof maxInputChars !== "number" ||
+            !Number.isInteger(maxInputChars) ||
+            maxInputChars <= 0)) {
+        return `Model "${model.modelName}" has an invalid maxInputChars value.`;
+    }
+    const speedRange = model.speedRange;
+    if (speedRange !== undefined) {
+        if (typeof speedRange !== "object" || speedRange === null) {
+            return `Model "${model.modelName}" has an invalid speedRange.`;
+        }
+        const min = speedRange.min;
+        const max = speedRange.max;
+        if (typeof min !== "number" ||
+            typeof max !== "number" ||
+            !Number.isFinite(min) ||
+            !Number.isFinite(max) ||
+            min > max) {
+            return `Model "${model.modelName}" has an invalid speedRange.`;
+        }
+    }
+    const formats = model.formats;
+    if (formats !== undefined &&
+        (!Array.isArray(formats) ||
+            !formats.every((format) => typeof format === "string"))) {
+        return `Model "${model.modelName}" has invalid formats.`;
+    }
+    return null;
+}
+/**
+ * Shared TTS behavior, mirroring BaseClient for text generation: the public
+ * speak() template method owns model-data-driven validation (char cap, speed
+ * range, format list), cost, and the single redacting/logging exception
+ * boundary. Subclasses implement only _speak(): SDK call + response mapping.
+ * A model with no registry entry skips validation — the provider is then the
+ * authority, matching how cost is silently omitted for unknown models.
+ */
+export class BaseSpeechClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async speak(text) {
+        try {
+            const model = getModelForProvider(this.config.provider, this.config.model, this.config.modelData);
+            if (model !== undefined && !isTextToSpeechModel(model)) {
+                return failure(`Model "${this.config.model}" is not a text-to-speech model.`);
+            }
+            if (model !== undefined) {
+                const constraintError = speechConstraintError(model);
+                if (constraintError !== null) {
+                    return failure(constraintError);
+                }
+                if (model.maxInputChars !== undefined && [...text].length > model.maxInputChars) {
+                    return failure(`Input exceeds the ${model.maxInputChars}-character limit for model "${this.config.model}".`);
+                }
+                if (this.config.speed !== undefined && model.speedRange !== undefined) {
+                    const { min, max } = model.speedRange;
+                    if (!Number.isFinite(this.config.speed) || this.config.speed < min || this.config.speed > max) {
+                        return failure(`speed must be a finite number in [${min}, ${max}].`);
+                    }
+                }
+                if (this.config.format !== undefined &&
+                    model.formats !== undefined &&
+                    !model.formats.includes(this.config.format)) {
+                    return failure(`Format "${this.config.format}" is not supported by model "${this.config.model}". ` +
+                        `Supported: ${model.formats.join(", ")}.`);
+                }
+            }
+            const result = await this._speak(text);
+            if (!result.success) {
+                return result;
+            }
+            const cost = calculateSpeechCost(model, [...text].length);
+            if (cost !== undefined) {
+                result.value.cost = cost;
+            }
+            return result;
+        }
+        catch (err) {
+            let msg = "speak() failed";
+            if (err instanceof Error) {
+                msg = err.message;
+            }
+            const redacted = redactSecret(msg, this.config.apiKey);
+            getLogger().error("speak() provider failed:", redacted);
+            return failure(redacted);
+        }
+    }
+}

package/dist/speech/openai.d.ts

@@ -0,0 +1,6 @@
+import { Result } from "../types/result.js";
+import { BaseSpeechClient } from "./baseSpeechClient.js";
+import type { SpeechResult } from "../speech.js";
+export declare class OpenAISpeechClient extends BaseSpeechClient {
+    protected _speak(text: string): Promise<Result<SpeechResult>>;
+}

package/dist/speech/openai.js

@@ -0,0 +1,39 @@
+import OpenAI from "openai";
+import { success, failure } from "../types/result.js";
+import { SPEECH_FORMAT_TO_MIME, isSpeakFormat, } from "../util/audioMime.js";
+import { BaseSpeechClient } from "./baseSpeechClient.js";
+export class OpenAISpeechClient extends BaseSpeechClient {
+    // No try/catch here: BaseSpeechClient.speak() is the single
+    // redacting/logging exception boundary.
+    async _speak(text) {
+        if (!this.config.apiKey) {
+            return failure("No OpenAI API key provided. Set apiKey.openAi or OPENAI_API_KEY.");
+        }
+        // The shared contract carries format as a plain string; narrow to OpenAI's
+        // closed union at runtime before indexing the MIME table.
+        const requestedFormat = this.config.format ?? "mp3";
+        if (!isSpeakFormat(requestedFormat)) {
+            return failure(`Format "${requestedFormat}" is not a supported OpenAI speech format. ` +
+                `Supported: ${Object.keys(SPEECH_FORMAT_TO_MIME).join(", ")}.`);
+        }
+        const format = requestedFormat;
+        const mimeType = SPEECH_FORMAT_TO_MIME[format];
+        const client = new OpenAI({ apiKey: this.config.apiKey });
+        const params = {
+            model: this.config.model,
+            voice: this.config.voice,
+            input: text,
+            response_format: format,
+        };
+        if (this.config.speed !== undefined) {
+            params.speed = this.config.speed;
+        }
+        const res = await client.audio.speech.create(params);
+        const audio = new Uint8Array(await res.arrayBuffer());
+        const result = { audio, mimeType };
+        if (format === "pcm") {
+            result.pcm = { sampleRateHz: 24000, sampleFormat: "s16le", channels: 1 };
+        }
+        return success(result);
+    }
+}

package/dist/speech.d.ts

@@ -0,0 +1,40 @@
+import type { ModelDataBlob } from "./modelData.js";
+import type { SmolConfig } from "./types.js";
+import { Result } from "./types/result.js";
+import { CostEstimate } from "./types/costEstimate.js";
+import { BaseSpeechClient, SpeechClientConfig } from "./speech/baseSpeechClient.js";
+export type SpeakOptions = {
+    model: string;
+    voice: string;
+    provider?: string;
+    modelData?: ModelDataBlob;
+    apiKey?: SmolConfig["apiKey"];
+    format?: string;
+    speed?: number;
+    metadata?: Record<string, unknown>;
+};
+export type PcmAudioMetadata = {
+    sampleRateHz: number;
+    /** Sample representation, e.g. "s16le"; provider-specific. */
+    sampleFormat: string;
+    channels: number;
+};
+export type SpeechResult = {
+    audio: Uint8Array;
+    mimeType: string;
+    pcm?: PcmAudioMetadata;
+    cost?: CostEstimate;
+    raw?: unknown;
+};
+export type SpeechClientClass = new (config: SpeechClientConfig) => BaseSpeechClient;
+export declare function registerSpeechProvider(name: string, cls: SpeechClientClass): void;
+/** Test-only: clear all registered custom providers so registrations don't leak across tests. */
+export declare function _resetForTests(): void;
+/**
+ * Resolve provider + API key and instantiate the matching speech client for
+ * the declarative speak() operation. Never throws: a custom client class's
+ * constructor can throw, and this internal factory's catch redacts the
+ * resolved key so a constructor error cannot leak through the public wrapper.
+ */
+export declare function getSpeechClient(opts: SpeakOptions): Result<BaseSpeechClient>;
+export declare function speak(text: string, opts: SpeakOptions): Promise<Result<SpeechResult>>;

package/dist/speech.js

@@ -0,0 +1,57 @@
+import { success, failure } from "./types/result.js";
+import { redactSecret } from "./util/redact.js";
+import { getLogger } from "./util/logger.js";
+import { resolveProvider, resolveApiKey } from "./util/provider.js";
+import { OpenAISpeechClient } from "./speech/openai.js";
+// Checked before the user registry so a registered "openai" can't hijack the built-in.
+const builtinClients = Object.create(null);
+builtinClients["openai"] = OpenAISpeechClient;
+// Null-prototype so provider names like "toString"/"__proto__" can't collide
+// with Object.prototype or pollute the registry.
+const registered = Object.create(null);
+export function registerSpeechProvider(name, cls) {
+    registered[name] = cls;
+}
+/** Test-only: clear all registered custom providers so registrations don't leak across tests. */
+export function _resetForTests() {
+    for (const key of Object.keys(registered)) {
+        delete registered[key];
+    }
+}
+/**
+ * Resolve provider + API key and instantiate the matching speech client for
+ * the declarative speak() operation. Never throws: a custom client class's
+ * constructor can throw, and this internal factory's catch redacts the
+ * resolved key so a constructor error cannot leak through the public wrapper.
+ */
+export function getSpeechClient(opts) {
+    let apiKeyForRedaction = "";
+    try {
+        const provider = resolveProvider(opts.model, opts.provider, opts.modelData);
+        const ClientClass = builtinClients[provider] ?? registered[provider];
+        if (ClientClass === undefined) {
+            return failure(`Provider "${provider}" has no speech API. Register one with registerSpeechProvider(name, ClientClass).`);
+        }
+        const apiKey = resolveApiKey(provider, opts) ?? "";
+        apiKeyForRedaction = apiKey;
+        const { apiKey: _callerKeys, ...clientOpts } = opts;
+        const config = { ...clientOpts, provider, apiKey };
+        return success(new ClientClass(config));
+    }
+    catch (err) {
+        let msg = "getSpeechClient() failed";
+        if (err instanceof Error) {
+            msg = err.message;
+        }
+        const redacted = redactSecret(msg, apiKeyForRedaction);
+        getLogger().error("getSpeechClient() failed:", redacted);
+        return failure(redacted);
+    }
+}
+export async function speak(text, opts) {
+    const client = getSpeechClient(opts);
+    if (!client.success) {
+        return client;
+    }
+    return client.value.speak(text);
+}

package/dist/transcription/baseTranscriptionClient.d.ts

@@ -0,0 +1,31 @@
+import type { ModelDataBlob } from "../modelData.js";
+import { Result } from "../types/result.js";
+import { BlobRef } from "../util/blobRef.js";
+import type { TranscriptionResult } from "../transcription.js";
+export declare const DEFAULT_TRANSCRIBE_BYTES: number;
+export type TranscriptionClientConfig = {
+    model: string;
+    /** Resolved provider name. */
+    provider: string;
+    /** Resolved API key; empty string when none was found. */
+    apiKey: string;
+    modelData?: ModelDataBlob;
+    language?: string;
+    prompt?: string;
+    timestampGranularity?: "segment" | "word";
+    maxBytes?: number;
+    metadata?: Record<string, unknown>;
+};
+/**
+ * Shared transcription behavior, mirroring BaseClient for text generation:
+ * the public transcribe() template method owns blob loading, model-data-driven
+ * validation, cost, and the single redacting/logging exception boundary.
+ * Subclasses implement only _transcribe(): SDK call + response mapping.
+ */
+export declare abstract class BaseTranscriptionClient {
+    protected config: TranscriptionClientConfig;
+    constructor(config: TranscriptionClientConfig);
+    transcribe(source: BlobRef): Promise<Result<TranscriptionResult>>;
+    /** Provider hook: SDK call + response mapping only; validation and cost live in the base. */
+    protected abstract _transcribe(data: Uint8Array, mimeType: string): Promise<Result<TranscriptionResult>>;
+}

package/dist/transcription/baseTranscriptionClient.js

@@ -0,0 +1,107 @@
+import { getModelForProvider, isSpeechToTextModel, } from "../models.js";
+import { calculateTranscriptionCost } from "../model.js";
+import { success, failure } from "../types/result.js";
+import { loadBlob } from "../util/blobRef.js";
+import { audioFormatForMime, canonicalizeMime } from "../util/mime.js";
+import { redactSecret } from "../util/redact.js";
+import { getLogger } from "../util/logger.js";
+export const DEFAULT_TRANSCRIBE_BYTES = 25 * 1024 * 1024;
+/** Validate the declarative STT constraint block once before consuming it. */
+function transcriptionConstraintError(model) {
+    const modelMaxBytes = model.maxBytes;
+    if (modelMaxBytes !== undefined &&
+        (typeof modelMaxBytes !== "number" || !Number.isFinite(modelMaxBytes) || modelMaxBytes <= 0)) {
+        return `Model "${model.modelName}" has an invalid maxBytes value.`;
+    }
+    const supportedMimeTypes = model.supportedMimeTypes;
+    if (supportedMimeTypes !== undefined &&
+        (!Array.isArray(supportedMimeTypes) ||
+            !supportedMimeTypes.every((mime) => typeof mime === "string"))) {
+        return `Model "${model.modelName}" has invalid supportedMimeTypes.`;
+    }
+    return null;
+}
+// The caller's maxBytes is a safety limit; the model's maxBytes is the
+// provider's hard cap. Take the smaller of whichever are present so a caller
+// can tighten the limit but never bypass the provider cap.
+function resolveTranscriptionMaxBytes(callerMaxBytes, model) {
+    if (callerMaxBytes !== undefined &&
+        (!Number.isFinite(callerMaxBytes) || callerMaxBytes <= 0)) {
+        return failure(`maxBytes must be a positive finite number (got ${callerMaxBytes}).`);
+    }
+    const limits = [];
+    if (callerMaxBytes !== undefined) {
+        limits.push(callerMaxBytes);
+    }
+    if (model?.maxBytes !== undefined) {
+        limits.push(model.maxBytes);
+    }
+    if (limits.length === 0) {
+        return success(DEFAULT_TRANSCRIBE_BYTES);
+    }
+    return success(Math.min(...limits));
+}
+/**
+ * Shared transcription behavior, mirroring BaseClient for text generation:
+ * the public transcribe() template method owns blob loading, model-data-driven
+ * validation, cost, and the single redacting/logging exception boundary.
+ * Subclasses implement only _transcribe(): SDK call + response mapping.
+ */
+export class BaseTranscriptionClient {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async transcribe(source) {
+        try {
+            const model = getModelForProvider(this.config.provider, this.config.model, this.config.modelData);
+            if (model !== undefined && !isSpeechToTextModel(model)) {
+                return failure(`Model "${this.config.model}" is not a speech-to-text model.`);
+            }
+            if (model !== undefined) {
+                const constraintError = transcriptionConstraintError(model);
+                if (constraintError !== null) {
+                    return failure(constraintError);
+                }
+            }
+            const effectiveLimit = resolveTranscriptionMaxBytes(this.config.maxBytes, model);
+            if (!effectiveLimit.success) {
+                return effectiveLimit;
+            }
+            let loaded;
+            try {
+                loaded = await loadBlob(source, { maxBytes: effectiveLimit.value });
+            }
+            catch (err) {
+                return failure(`Failed to load audio for transcription: ${err.message}`);
+            }
+            const mimeType = loaded.mimeType ?? "application/octet-stream";
+            if (model !== undefined && model.supportedMimeTypes !== undefined) {
+                const audioFormat = audioFormatForMime(mimeType);
+                const normalizedMime = audioFormat?.mimeType ?? canonicalizeMime(mimeType);
+                if (!model.supportedMimeTypes.includes(normalizedMime)) {
+                    return failure(`Unsupported audio type "${mimeType}" for model "${this.config.model}". ` +
+                        `Supported: ${model.supportedMimeTypes.join(", ")}.`);
+                }
+            }
+            const result = await this._transcribe(loaded.data, mimeType);
+            if (!result.success) {
+                return result;
+            }
+            const cost = calculateTranscriptionCost(model, result.value.durationSeconds);
+            if (cost !== undefined) {
+                result.value.cost = cost;
+            }
+            return result;
+        }
+        catch (err) {
+            let msg = "transcribe() failed";
+            if (err instanceof Error) {
+                msg = err.message;
+            }
+            const redacted = redactSecret(msg, this.config.apiKey);
+            getLogger().error("transcribe() provider failed:", redacted);
+            return failure(redacted);
+        }
+    }
+}