smoltalk 0.4.1 → 0.5.0

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);
+}