smoltalk 0.8.4 → 0.10.0

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;

package/dist/model.js

@@ -1,6 +1,7 @@
-import { getModel, isTextModel, ModelNameSchema } from "./models.js";
+import { getModel, getModelForProvider, isSpeechToTextModel, isTextModel, isTextToSpeechModel, ModelNameSchema, } from "./models.js";
 import { SmolError } from "./smolError.js";
 import { round } from "./util/util.js";
+const TOKEN_COST_UNIT = 1_000_000;
 export class Model {
     model;
     provider;
@@ -24,7 +25,13 @@ export class Model {
         return modelInfo ? modelInfo.provider : undefined;
     }
     calculateCost(usage) {
-        const model = getModel(this.model, this.modelData);
+        let model;
+        if (this.provider !== undefined) {
+            model = getModelForProvider(this.provider, this.model, this.modelData);
+        }
+        else {
+            model = getModel(this.model, this.modelData);
+        }
         if (!model || !isTextModel(model)) {
             return null;
         }
@@ -35,8 +42,15 @@ export class Model {
         // full input rate so totalCost stays honest.
         const cachedRate = model.cachedInputTokenCost ?? model.inputTokenCost ?? 0;
         const cacheCreationRate = model.cacheCreationInputTokenCost ?? model.inputTokenCost ?? 0;
-        const inputCost = round((usage.inputTokens * (model.inputTokenCost || 0)) / 1_000_000, 6);
-        const outputCost = round((usage.outputTokens * (model.outputTokenCost || 0)) / 1_000_000, 6);
+        const inputCost = round((usage.inputTokens * (model.inputTokenCost || 0)) / TOKEN_COST_UNIT, 6);
+        const outputCost = round((usage.outputTokens * (model.outputTokenCost || 0)) / TOKEN_COST_UNIT, 6);
+        const audioInTokens = usage.inputAudioTokens ?? 0;
+        const audioOutTokens = usage.outputAudioTokens ?? 0;
+        // Fall back to the text rate if no audio rate is defined so the total stays honest.
+        const audioInRate = model.inputAudioTokenCost ?? model.inputTokenCost ?? 0;
+        const audioOutRate = model.outputAudioTokenCost ?? model.outputTokenCost ?? 0;
+        const audioInCost = round((audioInTokens * audioInRate) / TOKEN_COST_UNIT, 6);
+        const audioOutCost = round((audioOutTokens * audioOutRate) / TOKEN_COST_UNIT, 6);
         // Only expose cachedInputCost / cacheCreationInputCost when the model
         // actually has a distinct discount price. Otherwise, fold those dollars
         // into inputCost so the user isn't misled by a $0 cached field.
@@ -61,14 +75,15 @@ export class Model {
                 foldedInputDollars += dollars;
             }
         }
-        const finalInputCost = round(inputCost + foldedInputDollars, 6);
+        const finalInputCost = round(inputCost + foldedInputDollars + audioInCost, 6);
+        const finalOutputCost = round(outputCost + audioOutCost, 6);
         const totalCost = round(finalInputCost +
-            outputCost +
+            finalOutputCost +
             (cachedInputCost || 0) +
             (cacheCreationInputCost || 0), 6);
         return {
             inputCost: finalInputCost,
-            outputCost,
+            outputCost: finalOutputCost,
             cachedInputCost,
             cacheCreationInputCost,
             totalCost,
@@ -88,3 +103,29 @@ export class Model {
         return new Model(model, provider, modelData);
     }
 }
+/**
+ * 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 function calculateTranscriptionCost(model, durationSeconds) {
+    if (model === undefined || !isSpeechToTextModel(model)) {
+        return undefined;
+    }
+    if (model.perMinuteCost === undefined || durationSeconds === undefined || durationSeconds === null) {
+        return undefined;
+    }
+    const inputCost = round((durationSeconds / 60) * model.perMinuteCost, 6);
+    return { inputCost, outputCost: 0, totalCost: inputCost, currency: "USD" };
+}
+/** Per-code-point TTS pricing from a registry entry; same omission semantics. */
+export function calculateSpeechCost(model, charCount) {
+    if (model === undefined || !isTextToSpeechModel(model)) {
+        return undefined;
+    }
+    if (model.perCharacterCost === undefined) {
+        return undefined;
+    }
+    const inputCost = round(charCount * model.perCharacterCost, 6);
+    return { inputCost, outputCost: 0, totalCost: inputCost, currency: "USD" };
+}

package/dist/models.d.ts

@@ -34,6 +34,23 @@ export type BaseModel = {
 export type SpeechToTextModel = BaseModel & {
     type: "speech-to-text";
     perMinuteCost?: number;
+    /** Canonical MIME types accepted after alias normalization through AUDIO_FORMATS. */
+    supportedMimeTypes?: readonly string[];
+    /** Provider upload cap in bytes. */
+    maxBytes?: number;
+};
+export type TextToSpeechModel = BaseModel & {
+    type: "text-to-speech";
+    perCharacterCost?: number;
+    /** Input cap in Unicode code points. */
+    maxInputChars?: number;
+    /** Accepted values for the speed option. */
+    speedRange?: {
+        min: number;
+        max: number;
+    };
+    /** Output formats the provider can render for this model. */
+    formats?: readonly string[];
 };
 export type ImageModel = BaseModel & {
     type: "image";
@@ -91,12 +108,37 @@ export type EmbeddingsModel = {
     provider: string;
     tokenCost?: number;
 };
-export type ModelType = SpeechToTextModel | TextModel | EmbeddingsModel | ImageModel;
+export type ModelType = SpeechToTextModel | TextToSpeechModel | TextModel | EmbeddingsModel | ImageModel;
 export declare const speechToTextModels: readonly [{
     readonly type: "speech-to-text";
-    readonly modelName: "whisper-web";
+    readonly modelName: "whisper-1";
     readonly perMinuteCost: 0.006;
     readonly provider: "openai";
+    readonly supportedMimeTypes: readonly ["audio/flac", "audio/mpeg", "audio/mp4", "audio/m4a", "audio/ogg", "audio/wav", "audio/webm"];
+    readonly maxBytes: number;
+}];
+export declare const textToSpeechModels: readonly [{
+    readonly type: "text-to-speech";
+    readonly modelName: "tts-1";
+    readonly perCharacterCost: 0.000015;
+    readonly provider: "openai";
+    readonly maxInputChars: 4096;
+    readonly speedRange: {
+        readonly min: 0.25;
+        readonly max: 4;
+    };
+    readonly formats: readonly ["mp3", "opus", "aac", "flac", "wav", "pcm"];
+}, {
+    readonly type: "text-to-speech";
+    readonly modelName: "tts-1-hd";
+    readonly perCharacterCost: 0.00003;
+    readonly provider: "openai";
+    readonly maxInputChars: 4096;
+    readonly speedRange: {
+        readonly min: 0.25;
+        readonly max: 4;
+    };
+    readonly formats: readonly ["mp3", "opus", "aac", "flac", "wav", "pcm"];
 }];
 export declare const textModels: readonly [{
     readonly type: "text";
@@ -810,16 +852,16 @@ export declare const textModels: readonly [{
 }, {
     readonly type: "text";
     readonly modelName: "gpt-5.6-terra";
-    readonly 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.";
+    readonly 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.";
     readonly maxInputTokens: 1050000;
     readonly maxOutputTokens: 128000;
-    readonly inputTokenCost: 2.5;
-    readonly cachedInputTokenCost: 0.25;
-    readonly outputTokenCost: 15;
+    readonly inputTokenCost: 2;
+    readonly cachedInputTokenCost: 0.2;
+    readonly outputTokenCost: 12;
     readonly longContext: {
-        readonly inputTokenCost: 5;
-        readonly cachedInputTokenCost: 0.5;
-        readonly outputTokenCost: 22.5;
+        readonly inputTokenCost: 4;
+        readonly cachedInputTokenCost: 0.4;
+        readonly outputTokenCost: 18;
         readonly thresholdTokens: 200000;
     };
     readonly reasoning: {
@@ -844,16 +886,16 @@ export declare const textModels: readonly [{
 }, {
     readonly type: "text";
     readonly modelName: "gpt-5.6-luna";
-    readonly 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.";
+    readonly 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.";
     readonly maxInputTokens: 1050000;
     readonly maxOutputTokens: 128000;
-    readonly inputTokenCost: 1;
-    readonly cachedInputTokenCost: 0.1;
-    readonly outputTokenCost: 6;
+    readonly inputTokenCost: 0.2;
+    readonly cachedInputTokenCost: 0.02;
+    readonly outputTokenCost: 1.2;
     readonly longContext: {
-        readonly inputTokenCost: 2;
-        readonly cachedInputTokenCost: 0.2;
-        readonly outputTokenCost: 9;
+        readonly inputTokenCost: 0.4;
+        readonly cachedInputTokenCost: 0.04;
+        readonly outputTokenCost: 1.8;
         readonly thresholdTokens: 200000;
     };
     readonly reasoning: {
@@ -938,10 +980,39 @@ export declare const textModels: readonly [{
     readonly temperatureSupported: true;
     readonly disabled: true;
     readonly provider: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-3.6-flash";
+    readonly 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.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 65536;
+    readonly inputTokenCost: 1.5;
+    readonly cachedInputTokenCost: 0.15;
+    readonly outputTokenCost: 7.5;
+    readonly inputAudioTokenCost: 1.5;
+    readonly reasoning: {
+        readonly levels: readonly ["minimal", "low", "medium", "high"];
+        readonly defaultLevel: "high";
+        readonly canDisable: false;
+        readonly outputsThinking: true;
+        readonly outputsSignatures: true;
+    };
+    readonly modalities: {
+        readonly input: readonly ["text", "image", "video", "audio", "pdf"];
+        readonly output: readonly ["text"];
+    };
+    readonly knowledge: "2026-03";
+    readonly releaseDate: "2026-07-21";
+    readonly lastUpdated: "2026-07-21";
+    readonly family: "gemini-flash";
+    readonly openWeights: false;
+    readonly structuredOutput: true;
+    readonly temperatureSupported: true;
+    readonly provider: "google";
 }, {
     readonly type: "text";
     readonly modelName: "gemini-3.5-flash";
-    readonly 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.";
+    readonly 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.";
     readonly maxInputTokens: 1048576;
     readonly maxOutputTokens: 65536;
     readonly inputTokenCost: 1.5;
@@ -997,10 +1068,39 @@ export declare const textModels: readonly [{
     readonly structuredOutput: true;
     readonly temperatureSupported: true;
     readonly provider: "google";
+}, {
+    readonly type: "text";
+    readonly modelName: "gemini-3.5-flash-lite";
+    readonly 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.";
+    readonly maxInputTokens: 1048576;
+    readonly maxOutputTokens: 65536;
+    readonly inputTokenCost: 0.3;
+    readonly cachedInputTokenCost: 0.03;
+    readonly outputTokenCost: 2.5;
+    readonly inputAudioTokenCost: 0.5;
+    readonly reasoning: {
+        readonly levels: readonly ["minimal", "low", "medium", "high"];
+        readonly defaultLevel: "minimal";
+        readonly canDisable: false;
+        readonly outputsThinking: true;
+        readonly outputsSignatures: true;
+    };
+    readonly modalities: {
+        readonly input: readonly ["text", "image", "video", "audio", "pdf"];
+        readonly output: readonly ["text"];
+    };
+    readonly knowledge: "2025-01";
+    readonly releaseDate: "2026-07-21";
+    readonly lastUpdated: "2026-07-21";
+    readonly family: "gemini-flash-lite";
+    readonly openWeights: false;
+    readonly structuredOutput: true;
+    readonly temperatureSupported: true;
+    readonly provider: "google";
 }, {
     readonly type: "text";
     readonly modelName: "gemini-3.1-flash-lite";
-    readonly 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.";
+    readonly 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.";
     readonly maxInputTokens: 1048576;
     readonly maxOutputTokens: 65536;
     readonly inputTokenCost: 0.25;
@@ -1558,6 +1658,21 @@ export declare const textModels: readonly [{
     readonly structuredOutput: true;
     readonly temperatureSupported: false;
     readonly provider: "openai-responses";
+}, {
+    readonly type: "text";
+    readonly modelName: "gpt-audio-1.5";
+    readonly description: "OpenAI GA audio chat model (Chat Completions). Text+audio in, text+audio out.";
+    readonly provider: "openai";
+    readonly modalities: {
+        readonly input: readonly ["text", "audio"];
+        readonly output: readonly ["text", "audio"];
+    };
+    readonly inputTokenCost: 2.5;
+    readonly outputTokenCost: 10;
+    readonly inputAudioTokenCost: 32;
+    readonly outputAudioTokenCost: 64;
+    readonly maxInputTokens: 128000;
+    readonly maxOutputTokens: 16384;
 }];
 export declare const imageModels: readonly [{
     readonly type: "image";
@@ -1610,6 +1725,7 @@ export declare const embeddingsModels: EmbeddingsModel[];
 export type TextModelName = (typeof textModels)[number]["modelName"];
 export type ImageModelName = (typeof imageModels)[number]["modelName"];
 export type SpeechToTextModelName = (typeof speechToTextModels)[number]["modelName"];
+export type TextToSpeechModelName = (typeof textToSpeechModels)[number]["modelName"];
 export type EmbeddingsModelName = (typeof embeddingsModels)[number]["modelName"];
 export type ModelName = string;
 export declare const hostedTools: HostedTool[];
@@ -1630,12 +1746,19 @@ export declare function getRegisteredModelData(): ModelDataBlob | null;
  */
 export declare function getAllModels(requestData?: ModelDataBlob): ModelType[];
 export declare function getModel(modelName: ModelName, requestData?: ModelDataBlob): ModelType | undefined;
+/**
+ * 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 declare function getModelForProvider(provider: string, modelName: ModelName, requestData?: ModelDataBlob): ModelType | undefined;
 /**
  * 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 declare function modelSupportsInputModality(modelName: ModelName, modality: string, requestData?: ModelDataBlob): boolean | undefined;
+export declare function modelSupportsInputModality(modelName: ModelName, modality: string, requestData?: ModelDataBlob, provider?: string): boolean | undefined;
 export declare function getHostedTools(opts?: {
     provider?: string;
     model?: string;
@@ -1647,5 +1770,6 @@ export declare function hostedToolPricingFor(tool: HostedTool, model?: string):
 export declare function isImageModel(model: ModelType): model is ImageModel;
 export declare function isTextModel(model: ModelType): model is TextModel;
 export declare function isSpeechToTextModel(model: ModelType): model is SpeechToTextModel;
+export declare function isTextToSpeechModel(model: ModelType): model is TextToSpeechModel;
 export declare function isEmbeddingsModel(model: ModelType): model is EmbeddingsModel;
 export declare const ModelNameSchema: z.ZodString;