smoltalk 0.9.0 → 0.10.1

package/dist/clients/baseClient.js

@@ -6,11 +6,21 @@ import { stripCodeFence } from "../util/util.js";
 import { success, failure, } from "../types.js";
 import { validateHostedTools } from "../util/hostedTools.js";
 import { resolveMessageAttachments, messagesHaveAttachments, DEFAULT_MAX_ATTACHMENT_BYTES } from "./resolveAttachments.js";
-import { validateModalities } from "../util/modalities.js";
+import { neededInputModalities, MODALITIES_REQUIRING_DECLARATION, } from "../util/modalities.js";
+import { modelSupportsInputModality } from "../models.js";
 import { resolveProvider } from "../util/provider.js";
 import { isUnconstrainedSchema } from "../util/jsonSchema.js";
 import { z } from "zod";
 const DEFAULT_NUM_RETRIES = 2;
+function clientSupportsAttachment(capabilities, modality) {
+    if (modality === "audio") {
+        return capabilities.audioFormats.length > 0;
+    }
+    if (modality === "image" || modality === "pdf") {
+        return capabilities.inputModalities.includes(modality);
+    }
+    return false;
+}
 export class BaseClient {
     config;
     statelogClient;
@@ -57,24 +67,43 @@ export class BaseClient {
         return null;
     }
     /**
-     * Gate on input modalities and resolve any image/PDF attachment refs
+     * What this client can accept as attachments. Subclasses override to declare
+     * more (or fewer). Checked against the messages, alongside the model's own
+     * declared modalities, before any serialization runs.
+     */
+    attachmentCapabilities() {
+        return { inputModalities: ["image", "pdf"], audioFormats: [] };
+    }
+    /**
+     * Gate on input modalities and resolve any image/PDF/audio attachment refs
      * (path/url/bytes → base64) before the synchronous serializers run. Returns
      * the (possibly rewritten) config on success, or a Failure to surface. Shared
      * by textSync and textStream so the two paths can't diverge.
      */
     async prepareAttachments(config) {
-        const modalityResult = validateModalities(config);
-        if (modalityResult && modalityResult.success === false) {
-            return modalityResult;
-        }
-        if (!messagesHaveAttachments(config.messages)) {
+        const needed = neededInputModalities(config.messages);
+        if (needed.length === 0 && !messagesHaveAttachments(config.messages)) {
             return success(config);
         }
         const provider = resolveProvider(config.model, config.provider, config.modelData);
+        const capabilities = this.attachmentCapabilities();
+        for (const modality of needed) {
+            if (!clientSupportsAttachment(capabilities, modality)) {
+                return failure(`${modality[0].toUpperCase()}${modality.slice(1)} input is not supported by the "${provider}" provider.`);
+            }
+            const supported = modelSupportsInputModality(config.model, modality, config.modelData, provider);
+            if (supported === false) {
+                return failure(`Model ${config.model} does not support ${modality} input.`);
+            }
+            if (supported === undefined && MODALITIES_REQUIRING_DECLARATION.has(modality)) {
+                return failure(`Model ${config.model} does not support ${modality} input.`);
+            }
+        }
         const maxBytes = config.attachments?.maxBytes ?? DEFAULT_MAX_ATTACHMENT_BYTES;
         const resolved = await resolveMessageAttachments(config.messages, {
             provider,
             maxBytes,
+            audioFormats: capabilities.audioFormats,
         });
         if (!resolved.success) {
             return resolved;

package/dist/clients/google.js

@@ -209,7 +209,7 @@ export class SmolGoogle extends BaseClient {
         }
         this.client = new GoogleGenAI({ apiKey });
         this.logger = getLogger();
-        this.model = new Model(config.model, undefined, config.modelData);
+        this.model = new Model(config.model, config.provider, config.modelData);
     }
     getClient() {
         return this.client;

package/dist/clients/ollama.js

@@ -20,7 +20,7 @@ export class SmolOllama extends BaseClient {
     constructor(config) {
         super(config);
         this.logger = getLogger();
-        this.model = new Model(config.model, undefined, config.modelData);
+        this.model = new Model(config.model, config.provider, config.modelData);
         const apiKey = config.apiKey?.ollama;
         if (apiKey) {
             this.client = new Ollama({

package/dist/clients/openai.d.ts

@@ -1,7 +1,7 @@
 import OpenAI from "openai";
 import { PromptResult, Result, SmolClient, SmolConfig, StreamChunk, HostedToolResult } from "../types.js";
 import { EgonLog } from "../util/logger.js";
-import { BaseClient } from "./baseClient.js";
+import { BaseClient, type ClientAttachmentCapabilities } from "./baseClient.js";
 import { ModelName } from "../models.js";
 import { Model } from "../model.js";
 import { CostEstimate, TokenUsage } from "../types.js";
@@ -11,6 +11,7 @@ export declare class SmolOpenAi extends BaseClient implements SmolClient {
     protected logger: EgonLog;
     protected model: Model;
     constructor(config: SmolOpenAiConfig);
+    protected attachmentCapabilities(): ClientAttachmentCapabilities;
     /**
      * Build the `new OpenAI({...})` options. Subclasses override to inject a
      * different baseURL or to pull the key from a different config field.

package/dist/clients/openai.js

@@ -20,7 +20,11 @@ export class SmolOpenAi extends BaseClient {
         const options = this.resolveClientOptions(config);
         this.client = new OpenAI(options);
         this.logger = getLogger();
-        this.model = new Model(config.model, undefined, config.modelData);
+        this.model = new Model(config.model, config.provider, config.modelData);
+    }
+    attachmentCapabilities() {
+        // Chat Completions input_audio accepts inline mp3/wav only.
+        return { inputModalities: ["image", "pdf"], audioFormats: ["mp3", "wav"] };
     }
     /**
      * Build the `new OpenAI({...})` options. Subclasses override to inject a
@@ -72,14 +76,22 @@ export class SmolOpenAi extends BaseClient {
         let cost;
         if (usageData) {
             const cached = usageData.prompt_tokens_details?.cached_tokens ?? 0;
+            const audioIn = usageData.prompt_tokens_details?.audio_tokens ?? 0;
+            const audioOut = usageData.completion_tokens_details?.audio_tokens ?? 0;
             usage = {
-                inputTokens: Math.max(0, (usageData.prompt_tokens || 0) - cached),
-                outputTokens: usageData.completion_tokens || 0,
+                inputTokens: Math.max(0, (usageData.prompt_tokens || 0) - cached - audioIn),
+                outputTokens: Math.max(0, (usageData.completion_tokens || 0) - audioOut),
                 totalTokens: usageData.total_tokens,
             };
             if (cached > 0) {
                 usage.cachedInputTokens = cached;
             }
+            if (audioIn > 0) {
+                usage.inputAudioTokens = audioIn;
+            }
+            if (audioOut > 0) {
+                usage.outputAudioTokens = audioOut;
+            }
             // Prefer provider-supplied cost when available (e.g. OpenRouter
             // usage.cost, DeepInfra usage.estimated_cost, LiteLLM header).
             // Fall back to the smoltalk model-registry calculation.

package/dist/clients/openaiCompat.d.ts

@@ -1,4 +1,5 @@
 import { SmolOpenAi } from "./openai.js";
+import type { ClientAttachmentCapabilities } from "./baseClient.js";
 import type { SmolConfig } from "../types.js";
 /**
  * Generic OpenAI-compatible client. Use when pointing smoltalk at any
@@ -14,6 +15,7 @@ import type { SmolConfig } from "../types.js";
  * cost stays undefined — that's expected for arbitrary backends).
  */
 export declare class SmolOpenAiCompat extends SmolOpenAi {
+    protected attachmentCapabilities(): ClientAttachmentCapabilities;
     protected resolveClientOptions(config: SmolConfig): {
         apiKey: string;
         baseURL: string;

package/dist/clients/openaiCompat.js

@@ -14,6 +14,11 @@ import { resolveApiKey, resolveBaseUrl } from "../util/provider.js";
  * cost stays undefined — that's expected for arbitrary backends).
  */
 export class SmolOpenAiCompat extends SmolOpenAi {
+    // Compat endpoints speak the Chat Completions wire format but do not get
+    // OpenAI's input_audio handling — declare no audio support.
+    attachmentCapabilities() {
+        return { inputModalities: ["image", "pdf"], audioFormats: [] };
+    }
     resolveClientOptions(config) {
         const apiKey = resolveApiKey("openai-compat", config);
         const baseURL = resolveBaseUrl("openai-compat", config);

package/dist/clients/openaiResponses.js

@@ -62,7 +62,7 @@ export class SmolOpenAiResponses extends BaseClient {
         }
         this.client = new OpenAI({ apiKey });
         this.logger = getLogger();
-        this.model = new Model(config.model, undefined, config.modelData);
+        this.model = new Model(config.model, config.provider, config.modelData);
     }
     getClient() {
         return this.client;

package/dist/clients/resolveAttachments.d.ts

@@ -1,11 +1,15 @@
 import { Message } from "../classes/message/index.js";
 import { Result } from "../types.js";
 export declare const DEFAULT_MAX_ATTACHMENT_BYTES: number;
+type ResolveOptions = {
+    provider: string;
+    maxBytes: number;
+    /** Audio containers (by primary extension) the target client accepts inline. */
+    audioFormats: readonly string[];
+};
 /** Whether any user message carries an image/file attachment part. */
 export declare function messagesHaveAttachments(messages: Message[]): boolean;
 /** Whether `provider` accepts a remote URL directly for this part type. */
 export declare function acceptsRemoteUrl(provider: string, partType: "image" | "file"): boolean;
-export declare function resolveMessageAttachments(messages: Message[], options: {
-    provider: string;
-    maxBytes: number;
-}): Promise<Result<Message[]>>;
+export declare function resolveMessageAttachments(messages: Message[], options: ResolveOptions): Promise<Result<Message[]>>;
+export {};

package/dist/clients/resolveAttachments.js

@@ -1,6 +1,7 @@
 import { UserMessage } from "../classes/message/index.js";
-import { normalizeImageRef } from "../util/imageRef.js";
+import { normalizeBlob } from "../util/blobRef.js";
 import { fileFamily } from "../util/attachments.js";
+import { audioFormatForMime } from "../util/mime.js";
 import { success, failure } from "../types.js";
 export const DEFAULT_MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
 const URL_IMAGE_PROVIDERS = new Set([
@@ -24,7 +25,7 @@ export function messagesHaveAttachments(messages) {
             continue;
         }
         for (const part of parts) {
-            if (part.type === "image" || part.type === "file") {
+            if (part.type === "image" || part.type === "file" || part.type === "audio") {
                 return true;
             }
         }
@@ -38,6 +39,100 @@ export function acceptsRemoteUrl(provider, partType) {
     }
     return URL_PDF_PROVIDERS.has(provider);
 }
+/** Load a ref to inline base64, gated to `allowed` MIME prefixes. Throws on failure. */
+async function toBase64Source(source, allowed, maxBytes) {
+    const { data, mimeType } = await normalizeBlob(source, {
+        allowedMimePrefixes: allowed,
+        maxBytes,
+    });
+    return { kind: "base64", base64: Buffer.from(data).toString("base64"), mimeType };
+}
+/** Error message when a providerFile ref targets the wrong provider family, else null. */
+function providerFileError(fileProvider, targetProvider) {
+    const family = fileFamily(targetProvider);
+    if (family === null || fileProvider !== family) {
+        return (`Attachment references a "${fileProvider}" file, but this call targets provider ` +
+            `"${targetProvider}" (file family ${family ?? "none"}).`);
+    }
+    return null;
+}
+// Audio has no providerFile/URL passthrough: Chat input_audio requires
+// inline base64, so every audio source is normalized here.
+async function resolveAudioPart(part, options) {
+    try {
+        const source = await toBase64Source(part.source, ["audio/"], options.maxBytes);
+        const audioFormat = audioFormatForMime(source.mimeType);
+        if (audioFormat === null || !options.audioFormats.includes(audioFormat.extension)) {
+            return failure(`Audio input for provider "${options.provider}" supports only ` +
+                `${options.audioFormats.join(", ")}; got "${source.mimeType}".`);
+        }
+        const resolved = { type: "audio", source };
+        if (part.filename !== undefined) {
+            resolved.filename = part.filename;
+        }
+        return success(resolved);
+    }
+    catch (err) {
+        return failure(`Failed to load audio attachment: ${err.message}`);
+    }
+}
+async function resolveImagePart(part, options) {
+    // Provider file references are validated and passed through (no download/cap).
+    if (part.source.kind === "providerFile") {
+        const mismatch = providerFileError(part.source.provider, options.provider);
+        if (mismatch !== null) {
+            return failure(mismatch);
+        }
+        if (options.provider === "openai") {
+            return failure("An image file reference requires the openai-responses provider (OpenAI Chat Completions has no image-by-file_id form).");
+        }
+        return success(part);
+    }
+    // Passthrough: keep a url ref when the target provider accepts a remote URL.
+    if (part.source.kind === "url" && acceptsRemoteUrl(options.provider, "image")) {
+        return success(part);
+    }
+    try {
+        const source = await toBase64Source(part.source, ["image/"], options.maxBytes);
+        return success({ type: "image", source });
+    }
+    catch (err) {
+        return failure(`Failed to load image attachment: ${err.message}`);
+    }
+}
+async function resolveFilePart(part, options) {
+    // Provider file references are validated and passed through (no download/cap).
+    if (part.source.kind === "providerFile") {
+        const mismatch = providerFileError(part.source.provider, options.provider);
+        if (mismatch !== null) {
+            return failure(mismatch);
+        }
+        return success(part);
+    }
+    // Passthrough: keep a url ref when the target provider accepts a remote URL.
+    if (part.source.kind === "url" && acceptsRemoteUrl(options.provider, "file")) {
+        return success(part);
+    }
+    try {
+        const source = await toBase64Source(part.source, ["application/pdf"], options.maxBytes);
+        return success({ type: "file", source, filename: part.filename });
+    }
+    catch (err) {
+        return failure(`Failed to load file attachment: ${err.message}`);
+    }
+}
+async function resolveUserPart(part, options) {
+    if (part.type === "text") {
+        return success(part);
+    }
+    if (part.type === "audio") {
+        return resolveAudioPart(part, options);
+    }
+    if (part.type === "image") {
+        return resolveImagePart(part, options);
+    }
+    return resolveFilePart(part, options);
+}
 export async function resolveMessageAttachments(messages, options) {
     const out = [];
     for (const msg of messages) {
@@ -52,55 +147,11 @@ export async function resolveMessageAttachments(messages, options) {
         }
         const resolvedParts = [];
         for (const part of parts) {
-            if (part.type === "text") {
-                resolvedParts.push(part);
-                continue;
-            }
-            // Provider file references are validated and passed through (no download/cap).
-            if (part.source.kind === "providerFile") {
-                const family = fileFamily(options.provider);
-                if (family === null || part.source.provider !== family) {
-                    return failure(`Attachment references a "${part.source.provider}" file, but this call targets provider ` +
-                        `"${options.provider}" (file family ${family ?? "none"}).`);
-                }
-                if (part.type === "image" && options.provider === "openai") {
-                    return failure("An image file reference requires the openai-responses provider (OpenAI Chat Completions has no image-by-file_id form).");
-                }
-                resolvedParts.push(part);
-                continue;
-            }
-            // Passthrough: keep a url ref when the target provider accepts a remote URL.
-            if (part.source.kind === "url" && acceptsRemoteUrl(options.provider, part.type)) {
-                resolvedParts.push(part);
-                continue;
-            }
-            let allowed;
-            if (part.type === "image") {
-                allowed = ["image/"];
-            }
-            else {
-                allowed = ["application/pdf"];
-            }
-            try {
-                const { data, mimeType } = await normalizeImageRef(part.source, {
-                    allowedMimePrefixes: allowed,
-                    maxBytes: options.maxBytes,
-                });
-                const source = {
-                    kind: "base64",
-                    base64: Buffer.from(data).toString("base64"),
-                    mimeType,
-                };
-                if (part.type === "image") {
-                    resolvedParts.push({ type: "image", source });
-                }
-                else {
-                    resolvedParts.push({ type: "file", source, filename: part.filename });
-                }
-            }
-            catch (err) {
-                return failure(`Failed to load ${part.type} attachment: ${err.message}`);
+            const resolved = await resolveUserPart(part, options);
+            if (!resolved.success) {
+                return resolved;
             }
+            resolvedParts.push(resolved.value);
         }
         out.push(new UserMessage(resolvedParts, { name: msg.name, rawData: msg.rawData }));
     }

package/dist/embed.d.ts

@@ -16,6 +16,8 @@ export type EmbedConfig = {
         deepInfra?: string;
         liteLlm?: string;
         openAiCompat?: string;
+        /** Arbitrary provider names, for keys targeting a custom-registered provider. */
+        [provider: string]: string | undefined;
     };
     /** Custom base URLs, nested by provider. */
     baseUrl?: {
@@ -23,6 +25,8 @@ export type EmbedConfig = {
         deepInfra?: string;
         liteLlm?: string;
         openAiCompat?: string;
+        /** Arbitrary provider names, for URLs targeting a custom-registered provider. */
+        [provider: string]: string | undefined;
     };
     metadata?: Record<string, unknown>;
     modelData?: ModelDataBlob;

package/dist/files.d.ts

@@ -1,7 +1,7 @@
 import { Result } from "./types/result.js";
 import type { SmolConfig } from "./types.js";
 import { ProviderFileRef } from "./classes/message/contentParts.js";
-import { BlobRef } from "./util/imageRef.js";
+import { BlobRef } from "./util/blobRef.js";
 /** Default cap on a resolved upload's size. Callers can raise it via opts.maxBytes. */
 export declare const DEFAULT_UPLOAD_BYTES: number;
 /**

package/dist/files.js

@@ -1,5 +1,5 @@
 import { failure } from "./types/result.js";
-import { loadBlob } from "./util/imageRef.js";
+import { loadBlob } from "./util/blobRef.js";
 import { fileFamily } from "./util/attachments.js";
 import { resolveApiKey } from "./util/provider.js";
 import { openaiFileProvider } from "./files/openai.js";

package/dist/image/google.js

@@ -1,7 +1,7 @@
 import { GoogleGenAI } from "@google/genai";
 import { success, failure } from "../types/result.js";
 import { getModel, isImageModel } from "../models.js";
-import { normalizeImageRef } from "../util/imageRef.js";
+import { normalizeBlob } from "../util/blobRef.js";
 import { COST_DECIMAL_PLACES, round } from "../util/util.js";
 export async function googleImage(input, config, apiKey) {
     try {
@@ -9,7 +9,7 @@ export async function googleImage(input, config, apiKey) {
         const client = new GoogleGenAI({ apiKey });
         const parts = [{ text: normalized.prompt }];
         if (normalized.images && normalized.images.length > 0) {
-            const normalizedImages = await Promise.all(normalized.images.map((ref) => normalizeImageRef(ref)));
+            const normalizedImages = await Promise.all(normalized.images.map((ref) => normalizeBlob(ref)));
             for (const img of normalizedImages) {
                 parts.push({
                     inlineData: {

package/dist/image/openai.js

@@ -2,7 +2,7 @@ import OpenAI from "openai";
 import { toFile } from "openai/uploads";
 import { success, failure } from "../types/result.js";
 import { getModel, isImageModel } from "../models.js";
-import { normalizeImageRef } from "../util/imageRef.js";
+import { normalizeBlob } from "../util/blobRef.js";
 import { COST_DECIMAL_PLACES, omitUndefined, round, tokenCost, } from "../util/util.js";
 export async function openaiImage(input, config, apiKey) {
     try {
@@ -51,11 +51,11 @@ function buildBaseParams(config, prompt) {
 }
 async function callEdit(client, baseParams, normalized) {
     const imageFiles = await Promise.all((normalized.images ?? []).map(async (ref, i) => {
-        const n = await normalizeImageRef(ref);
+        const n = await normalizeBlob(ref);
         return toFileFor(n, `image-${i}`);
     }));
     const maskFile = normalized.mask
-        ? await toFileFor(await normalizeImageRef(normalized.mask), "mask")
+        ? await toFileFor(await normalizeBlob(normalized.mask), "mask")
         : undefined;
     return client.images.edit(omitUndefined({
         ...baseParams,

package/dist/image.d.ts

@@ -2,7 +2,7 @@ import type { ModelDataBlob } from "./modelData.js";
 import { Result } from "./types/result.js";
 import { TokenUsage } from "./types/tokenUsage.js";
 import { CostEstimate } from "./types/costEstimate.js";
-import { ImageRef } from "./util/imageRef.js";
+import { ImageRef } from "./util/blobRef.js";
 export { ImageRef };
 export type ImageInput = string | {
     prompt: string;

package/dist/index.d.ts

@@ -13,8 +13,16 @@ export * from "./embed.js";
 export * from "./image.js";
 export { uploadFile, deleteFile, registerFileProvider, DEFAULT_UPLOAD_BYTES } from "./files.js";
 export type { UploadFileOptions, FileProviderContext, FileProvider } from "./files.js";
-export { normalizeImageRef, loadBlob } from "./util/imageRef.js";
-export type { BlobRef } from "./util/imageRef.js";
+export { normalizeBlob, loadBlob } from "./util/blobRef.js";
+export type { BlobRef } from "./util/blobRef.js";
 export { getLogger, EgonLog } from "./util/logger.js";
 export type { LogLevel } from "./util/logger.js";
 export { redactAttachments } from "./util/redact.js";
+export { transcribe, registerTranscriptionProvider, DEFAULT_TRANSCRIBE_BYTES, } from "./transcription.js";
+export type { TranscribeOptions, TranscriptionSegment, TranscriptionWord, TranscriptionResult, TranscriptionClientClass, } from "./transcription.js";
+export { BaseTranscriptionClient } from "./transcription/baseTranscriptionClient.js";
+export type { TranscriptionClientConfig } from "./transcription/baseTranscriptionClient.js";
+export { speak, registerSpeechProvider, } from "./speech.js";
+export type { SpeakOptions, PcmAudioMetadata, SpeechResult, SpeechClientClass, } from "./speech.js";
+export { BaseSpeechClient } from "./speech/baseSpeechClient.js";
+export type { SpeechClientConfig } from "./speech/baseSpeechClient.js";

package/dist/index.js

@@ -13,6 +13,12 @@ export * from "./embed.js";
 export * from "./image.js";
 // Explicit (not `export *`) so the test-only `_resetForTests` stays off the public surface.
 export { uploadFile, deleteFile, registerFileProvider, DEFAULT_UPLOAD_BYTES } from "./files.js";
-export { normalizeImageRef, loadBlob } from "./util/imageRef.js";
+export { normalizeBlob, loadBlob } from "./util/blobRef.js";
 export { getLogger, EgonLog } from "./util/logger.js";
 export { redactAttachments } from "./util/redact.js";
+// Explicit (not `export *`) so internal factories and test helpers stay private.
+export { transcribe, registerTranscriptionProvider, DEFAULT_TRANSCRIBE_BYTES, } from "./transcription.js";
+export { BaseTranscriptionClient } from "./transcription/baseTranscriptionClient.js";
+// Explicit (not `export *`) so internal factories and test helpers stay private.
+export { speak, registerSpeechProvider, } from "./speech.js";
+export { BaseSpeechClient } from "./speech/baseSpeechClient.js";

package/dist/model.d.ts

@@ -1,19 +1,22 @@
-import { ModelName, Provider } from "./models.js";
+import { ModelName, ModelType } from "./models.js";
 import { ModelLike } from "./types.js";
 import type { ModelDataBlob } from "./modelData.js";
+import type { CostEstimate } from "./types/costEstimate.js";
 export declare class Model {
     private model;
     private provider?;
     private modelData?;
-    constructor(model: ModelName, provider?: Provider, modelData?: ModelDataBlob);
+    constructor(model: ModelName, provider?: string, modelData?: ModelDataBlob);
     getModel(): ModelName;
-    getProvider(): Provider | undefined;
+    getProvider(): string | undefined;
     private lookupProvider;
     calculateCost(usage: {
         inputTokens: number;
         outputTokens: number;
         cachedInputTokens?: number;
         cacheCreationInputTokens?: number;
+        inputAudioTokens?: number;
+        outputAudioTokens?: number;
     }): {
         inputCost: number;
         outputCost: number;
@@ -24,5 +27,13 @@ export declare class Model {
     } | null;
     toString(): string;
     toJSON(): ModelName;
-    static create(model: ModelLike, provider?: Provider, modelData?: ModelDataBlob): Model;
+    static create(model: ModelLike, provider?: string, modelData?: ModelDataBlob): Model;
 }
+/**
+ * Per-minute STT pricing from a registry entry. Returns undefined (cost
+ * omitted, no error) when the model, rate, or duration is unknown — a rate of
+ * 0 still yields a present zero cost.
+ */
+export declare function calculateTranscriptionCost(model: ModelType | undefined, durationSeconds: number | undefined): CostEstimate | undefined;
+/** Per-code-point TTS pricing from a registry entry; same omission semantics. */
+export declare function calculateSpeechCost(model: ModelType | undefined, charCount: number): CostEstimate | undefined;