smoltalk 0.4.2 → 0.5.0

package/dist/embed.js

@@ -3,11 +3,17 @@ import { resolveProvider, resolveApiKey } from "./util/provider.js";
 import { openaiEmbed } from "./embed/openai.js";
 import { googleEmbed } from "./embed/google.js";
 import { ollamaEmbed } from "./embed/ollama.js";
+// Null-prototype so provider names like "toString"/"__proto__" can't collide
+// with Object.prototype or pollute the registry.
+const registeredEmbedProviders = Object.create(null);
+export function registerEmbeddingProvider(name, fn) {
+    registeredEmbedProviders[name] = fn;
+}
 export async function embed(input, config) {
     const inputs = Array.isArray(input) ? input : [input];
     let provider;
     try {
-        provider = resolveProvider(config.model, config.provider);
+        provider = resolveProvider(config.model, config.provider, config.modelData);
     }
     catch (err) {
         return failure(err instanceof Error ? err.message : "Failed to resolve provider");
@@ -29,7 +35,12 @@ export async function embed(input, config) {
         }
         case "ollama":
             return ollamaEmbed(inputs, config, apiKey, config.ollamaHost);
-        default:
-            return failure(`Provider "${provider}" does not support embeddings`);
+        default: {
+            const custom = registeredEmbedProviders[provider];
+            if (custom) {
+                return custom(inputs, config);
+            }
+            return failure(`Provider "${provider}" does not support embeddings. Register one with registerEmbeddingProvider(name, fn).`);
+        }
     }
 }

package/dist/image/google.js

@@ -41,15 +41,15 @@ export async function googleImage(input, config, apiKey) {
         return success({
             images,
             model: config.model,
-            costEstimate: calculateGoogleImageCost(config.model, images.length),
+            costEstimate: calculateGoogleImageCost(config.model, images.length, config.modelData),
         });
     }
     catch (err) {
         return failure(err instanceof Error ? err.message : "Google image request failed");
     }
 }
-function calculateGoogleImageCost(modelName, imageCount) {
-    const model = getModel(modelName);
+function calculateGoogleImageCost(modelName, imageCount, modelData) {
+    const model = getModel(modelName, modelData);
     if (!model || !isImageModel(model) || !model.costPerImage)
         return undefined;
     const totalCost = round(model.costPerImage * imageCount, COST_DECIMAL_PLACES);

package/dist/image/openai.js

@@ -24,8 +24,8 @@ export async function openaiImage(input, config, apiKey) {
         }));
         const tokenUsage = extractUsage(response);
         const costEstimate = tokenUsage
-            ? calculateImageCost(config.model, tokenUsage)
-            : calculatePerImageCost(config.model, images.length);
+            ? calculateImageCost(config.model, tokenUsage, config.modelData)
+            : calculatePerImageCost(config.model, images.length, config.modelData);
         return success({
             images,
             model: config.model,
@@ -97,8 +97,8 @@ function extractUsage(response) {
         totalTokens: u.total_tokens,
     };
 }
-function calculateImageCost(modelName, usage) {
-    const model = getModel(modelName);
+function calculateImageCost(modelName, usage, modelData) {
+    const model = getModel(modelName, modelData);
     if (!model || !isImageModel(model))
         return undefined;
     const totalIn = usage.inputTokens ?? 0;
@@ -131,8 +131,8 @@ function calculateImageCost(modelName, usage) {
         currency: "USD",
     };
 }
-function calculatePerImageCost(modelName, imageCount) {
-    const model = getModel(modelName);
+function calculatePerImageCost(modelName, imageCount, modelData) {
+    const model = getModel(modelName, modelData);
     if (!model || !isImageModel(model) || !model.costPerImage)
         return undefined;
     const totalCost = round(model.costPerImage * imageCount, COST_DECIMAL_PLACES);

package/dist/image.d.ts

@@ -1,4 +1,4 @@
-import { Provider } from "./models.js";
+import type { ModelDataBlob } from "./modelData.js";
 import { Result } from "./types/result.js";
 import { TokenUsage } from "./types/tokenUsage.js";
 import { CostEstimate } from "./types/costEstimate.js";
@@ -11,7 +11,7 @@ export type ImageInput = string | {
 };
 export type ImageConfig = {
     model: string;
-    provider?: Provider;
+    provider?: string;
     n?: number;
     size?: string;
     quality?: "low" | "medium" | "high" | "auto";
@@ -20,6 +20,7 @@ export type ImageConfig = {
     openAiApiKey?: string;
     googleApiKey?: string;
     metadata?: Record<string, unknown>;
+    modelData?: ModelDataBlob;
 };
 export type GeneratedImage = {
     data: Uint8Array;
@@ -32,4 +33,6 @@ export type ImageGenResult = {
     tokenUsage?: TokenUsage;
     costEstimate?: CostEstimate;
 };
+export type ImageProvider = (input: ImageInput, config: ImageConfig) => Promise<Result<ImageGenResult>>;
+export declare function registerImageProvider(name: string, fn: ImageProvider): void;
 export declare function image(input: ImageInput, config: ImageConfig): Promise<Result<ImageGenResult>>;

package/dist/image.js

@@ -2,10 +2,16 @@ import { failure } from "./types/result.js";
 import { resolveProvider, resolveApiKey } from "./util/provider.js";
 import { openaiImage } from "./image/openai.js";
 import { googleImage } from "./image/google.js";
+// Null-prototype so provider names like "toString"/"__proto__" can't collide
+// with Object.prototype or pollute the registry.
+const registeredImageProviders = Object.create(null);
+export function registerImageProvider(name, fn) {
+    registeredImageProviders[name] = fn;
+}
 export async function image(input, config) {
     let provider;
     try {
-        provider = resolveProvider(config.model, config.provider);
+        provider = resolveProvider(config.model, config.provider, config.modelData);
     }
     catch (err) {
         return failure(err instanceof Error ? err.message : "Failed to resolve provider");
@@ -31,7 +37,12 @@ export async function image(input, config) {
             }
             return googleImage(input, config, apiKey);
         }
-        default:
-            return failure(`Provider "${provider}" does not support image generation`);
+        default: {
+            const custom = registeredImageProviders[provider];
+            if (custom) {
+                return custom(input, config);
+            }
+            return failure(`Provider "${provider}" does not support image generation. Register one with registerImageProvider(name, fn).`);
+        }
     }
 }

package/dist/index.d.ts

@@ -1,6 +1,7 @@
 export * from "./client.js";
 export * from "./types.js";
 export * from "./models.js";
+export * from "./modelData.js";
 export * from "./model.js";
 export * from "./smolError.js";
 export * from "./util/util.js";

package/dist/index.js

@@ -1,6 +1,7 @@
 export * from "./client.js";
 export * from "./types.js";
 export * from "./models.js";
+export * from "./modelData.js";
 export * from "./model.js";
 export * from "./smolError.js";
 export * from "./util/util.js";

package/dist/model.d.ts

@@ -1,9 +1,11 @@
 import { ModelName, Provider } from "./models.js";
 import { ModelLike } from "./types.js";
+import type { ModelDataBlob } from "./modelData.js";
 export declare class Model {
     private model;
     private provider?;
-    constructor(model: ModelName, provider?: Provider);
+    private modelData?;
+    constructor(model: ModelName, provider?: Provider, modelData?: ModelDataBlob);
     getModel(): ModelName;
     getProvider(): Provider | undefined;
     private lookupProvider;
@@ -22,5 +24,5 @@ export declare class Model {
     } | null;
     toString(): string;
     toJSON(): ModelName;
-    static create(model: ModelLike, provider?: Provider): Model;
+    static create(model: ModelLike, provider?: Provider, modelData?: ModelDataBlob): Model;
 }

package/dist/model.js

@@ -4,11 +4,13 @@ import { round } from "./util/util.js";
 export class Model {
     model;
     provider;
-    constructor(model, provider) {
+    modelData;
+    constructor(model, provider, modelData) {
         if (!ModelNameSchema.safeParse(model).success) {
             throw new SmolError(`Model ${JSON.stringify(model)} is not recognized. Please specify a known model name.`);
         }
         this.model = model;
+        this.modelData = modelData;
         this.provider = provider || this.lookupProvider();
     }
     getModel() {
@@ -18,11 +20,11 @@ export class Model {
         return this.provider;
     }
     lookupProvider() {
-        const modelInfo = getModel(this.model);
+        const modelInfo = getModel(this.model, this.modelData);
         return modelInfo ? modelInfo.provider : undefined;
     }
     calculateCost(usage) {
-        const model = getModel(this.model);
+        const model = getModel(this.model, this.modelData);
         if (!model || !isTextModel(model)) {
             return null;
         }
@@ -79,10 +81,10 @@ export class Model {
     toJSON() {
         return this.model;
     }
-    static create(model, provider) {
+    static create(model, provider, modelData) {
         if (model instanceof Model) {
             return model;
         }
-        return new Model(model, provider);
+        return new Model(model, provider, modelData);
     }
 }

package/dist/modelData.d.ts

@@ -0,0 +1,40 @@
+import type { ModelType } from "./models.js";
+import { Result } from "./types/result.js";
+export declare const SUPPORTED_SCHEMA_VERSION = 1;
+export type HostedToolPrice = {
+    unit: "per_call" | "per_session" | "per_hour" | "per_gb_day" | "tokens" | "free";
+    amount?: number;
+    freeAllowance?: string;
+    note?: string;
+};
+export type HostedToolPricing = HostedToolPrice & {
+    perModel?: Record<string, Partial<HostedToolPrice>>;
+};
+export type HostedTool = {
+    name: string;
+    provider: string;
+    category?: string;
+    description?: string;
+    providerToolId?: string;
+    models?: string[];
+    pricing?: HostedToolPricing;
+    disabled?: boolean;
+};
+export type ModelDataBlob = {
+    schemaVersion: number;
+    generatedAt: string;
+    models: ModelType[];
+    hostedTools: HostedTool[];
+};
+export declare function parseModelDataBlob(raw: string): Result<ModelDataBlob>;
+export declare function deepMergeEntry<T>(base: T, overlay: T): T;
+export declare function mergeModelData(base: ModelType[], overlay: ModelType[]): ModelType[];
+export declare function mergeHostedTools(base: HostedTool[], overlay: HostedTool[]): HostedTool[];
+export declare const DEFAULT_MODEL_DATA_URL = "https://raw.githubusercontent.com/egonSchiele/smoltalk/main/packages/smoltalk/data/model-data.json";
+export type Fetcher = (url: string, signal?: AbortSignal) => Promise<string>;
+export type RefreshOptions = {
+    url?: string;
+    fetcher?: Fetcher;
+    signal?: AbortSignal;
+};
+export declare function refreshModels(opts?: RefreshOptions): Promise<Result<ModelDataBlob>>;

package/dist/modelData.js

@@ -0,0 +1,222 @@
+import z from "zod";
+import { readFile } from "node:fs/promises";
+import { fileURLToPath } from "node:url";
+import { success, failure } from "./types/result.js";
+export const SUPPORTED_SCHEMA_VERSION = 1;
+const EnvelopeSchema = z.object({
+    schemaVersion: z.number(),
+    generatedAt: z.string(),
+    models: z.array(z.unknown()),
+    hostedTools: z.array(z.unknown()).optional(),
+});
+// Permissive: require the fields smoltalk keys on, keep everything else.
+const ModelEntrySchema = z
+    .object({
+    modelName: z.string(),
+    provider: z.string(),
+    type: z.string(),
+})
+    .catchall(z.unknown());
+// Per-model override: price fields only. No `.catchall`, so unknown keys
+// (including a stray nested `perModel`) are stripped — the resolver can never
+// reintroduce perModel into its result.
+const PerModelPriceSchema = z.object({
+    unit: z.string().optional(),
+    amount: z.number().optional(),
+    freeAllowance: z.string().optional(),
+    note: z.string().optional(),
+});
+// `unit` stays a lenient string (forward-compat, mirroring ModelEntrySchema's
+// `type: z.string()`); the closed union is the known/intended set.
+const HostedToolPricingSchema = z
+    .object({
+    unit: z.string(),
+    amount: z.number().optional(),
+    freeAllowance: z.string().optional(),
+    note: z.string().optional(),
+    perModel: z.record(z.string(), PerModelPriceSchema).optional(),
+})
+    .catchall(z.unknown());
+const HostedToolSchema = z
+    .object({
+    name: z.string(),
+    provider: z.string(),
+    category: z.string().optional(),
+    description: z.string().optional(),
+    providerToolId: z.string().optional(),
+    models: z.array(z.string()).optional(),
+    pricing: HostedToolPricingSchema.optional(),
+    disabled: z.boolean().optional(),
+})
+    .catchall(z.unknown());
+export function parseModelDataBlob(raw) {
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch (err) {
+        return failure(`Model data is not valid JSON: ${String(err)}`);
+    }
+    const envelope = EnvelopeSchema.safeParse(json);
+    if (!envelope.success) {
+        return failure(`Model data blob is malformed: ${z.prettifyError(envelope.error)}`);
+    }
+    if (envelope.data.schemaVersion > SUPPORTED_SCHEMA_VERSION) {
+        return failure(`Model data schemaVersion ${envelope.data.schemaVersion} is newer than this smoltalk supports (${SUPPORTED_SCHEMA_VERSION}). Please upgrade smoltalk.`);
+    }
+    const models = [];
+    for (const entry of envelope.data.models) {
+        const parsed = ModelEntrySchema.safeParse(entry);
+        if (!parsed.success) {
+            console.warn(`Skipping invalid model entry: ${z.prettifyError(parsed.error)}`);
+            continue;
+        }
+        models.push(parsed.data);
+    }
+    const hostedTools = [];
+    let rawTools = [];
+    if (envelope.data.hostedTools) {
+        rawTools = envelope.data.hostedTools;
+    }
+    for (const entry of rawTools) {
+        const parsed = HostedToolSchema.safeParse(entry);
+        if (!parsed.success) {
+            console.warn(`Skipping invalid hosted tool: ${z.prettifyError(parsed.error)}`);
+            continue;
+        }
+        hostedTools.push(parsed.data);
+    }
+    return success({
+        schemaVersion: envelope.data.schemaVersion,
+        generatedAt: envelope.data.generatedAt,
+        models,
+        hostedTools,
+    });
+}
+function isPlainObject(value) {
+    if (value === null) {
+        return false;
+    }
+    if (typeof value !== "object") {
+        return false;
+    }
+    if (Array.isArray(value)) {
+        return false;
+    }
+    return true;
+}
+export function deepMergeEntry(base, overlay) {
+    if (!isPlainObject(base) || !isPlainObject(overlay)) {
+        return overlay;
+    }
+    const result = { ...base };
+    for (const key of Object.keys(overlay)) {
+        const overValue = overlay[key];
+        if (overValue === undefined) {
+            continue;
+        }
+        const currentValue = result[key];
+        if (isPlainObject(currentValue) && isPlainObject(overValue)) {
+            result[key] = deepMergeEntry(currentValue, overValue);
+        }
+        else {
+            result[key] = overValue;
+        }
+    }
+    return result;
+}
+function mergeByKey(base, overlay, keyOf) {
+    const order = [];
+    const map = new Map();
+    for (const item of base) {
+        const key = keyOf(item);
+        if (!map.has(key)) {
+            order.push(key);
+        }
+        map.set(key, item);
+    }
+    for (const item of overlay) {
+        const key = keyOf(item);
+        const existing = map.get(key);
+        if (existing === undefined) {
+            order.push(key);
+            map.set(key, item);
+        }
+        else {
+            map.set(key, deepMergeEntry(existing, item));
+        }
+    }
+    return order.map((key) => map.get(key));
+}
+export function mergeModelData(base, overlay) {
+    return mergeByKey(base, overlay, (m) => `${m.provider}:${m.modelName}`);
+}
+export function mergeHostedTools(base, overlay) {
+    return mergeByKey(base, overlay, (t) => `${t.provider}:${t.name}`);
+}
+export const DEFAULT_MODEL_DATA_URL = "https://raw.githubusercontent.com/egonSchiele/smoltalk/main/packages/smoltalk/data/model-data.json";
+const MAX_BYTES = 10_000_000;
+const TIMEOUT_MS = 15_000;
+function enforceSizeCap(text) {
+    if (Buffer.byteLength(text, "utf8") > MAX_BYTES) {
+        throw new Error(`Model data exceeds the ${MAX_BYTES}-byte cap`);
+    }
+    return text;
+}
+// The default fetcher supports remote https:// URLs and local file:// URLs.
+// file:// lets users point at a self-hosted on-disk catalog (and powers the
+// integration test). Any other scheme is rejected.
+async function defaultFetcher(url, signal) {
+    if (url.startsWith("file://")) {
+        const path = fileURLToPath(url);
+        const text = await readFile(path, "utf8");
+        return enforceSizeCap(text);
+    }
+    if (url.startsWith("https://")) {
+        const res = await fetch(url, { signal });
+        if (!res.ok) {
+            throw new Error(`HTTP ${res.status} ${res.statusText}`);
+        }
+        return enforceSizeCap(await res.text());
+    }
+    throw new Error(`Unsupported model-data URL scheme (expected https:// or file://): ${url}`);
+}
+export async function refreshModels(opts = {}) {
+    let url = DEFAULT_MODEL_DATA_URL;
+    if (process.env.SMOLTALK_MODEL_DATA_URL) {
+        url = process.env.SMOLTALK_MODEL_DATA_URL;
+    }
+    if (opts.url) {
+        url = opts.url;
+    }
+    let fetcher = defaultFetcher;
+    if (opts.fetcher) {
+        fetcher = opts.fetcher;
+    }
+    // Always drive the fetcher off our own controller so the timeout can abort
+    // it. Forward an externally-supplied signal into the same controller so both
+    // the timeout and the caller can cancel.
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), TIMEOUT_MS);
+    if (opts.signal) {
+        if (opts.signal.aborted) {
+            controller.abort();
+        }
+        else {
+            opts.signal.addEventListener("abort", () => controller.abort(), {
+                once: true,
+            });
+        }
+    }
+    let raw;
+    try {
+        raw = await fetcher(url, controller.signal);
+    }
+    catch (err) {
+        return failure(`Could not fetch model data from ${url}: ${String(err)}`);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    return parseModelDataBlob(raw);
+}