smoltalk 0.2.2 → 0.3.0

package/dist/util/imageRef.d.ts

@@ -0,0 +1,29 @@
+export type ImageRef = {
+    kind: "bytes";
+    data: Uint8Array;
+    mimeType: string;
+} | {
+    kind: "base64";
+    base64: string;
+    mimeType: string;
+} | {
+    kind: "path";
+    path: string;
+    mimeType?: string;
+} | {
+    kind: "url";
+    url: string;
+    mimeType?: string;
+    /**
+     * Maximum time in milliseconds to wait for the URL to respond before
+     * aborting. Defaults to {@link DEFAULT_FETCH_TIMEOUT_MS} (60 seconds).
+     */
+    timeoutMs?: number;
+};
+export type NormalizedImage = {
+    data: Uint8Array;
+    mimeType: string;
+};
+/** Default timeout for fetching image URLs during normalization (60 seconds). */
+export declare const DEFAULT_FETCH_TIMEOUT_MS = 60000;
+export declare function normalizeImageRef(ref: ImageRef): Promise<NormalizedImage>;

package/dist/util/imageRef.js

@@ -0,0 +1,51 @@
+import { readFile } from "node:fs/promises";
+import { extname } from "node:path";
+/** Default timeout for fetching image URLs during normalization (60 seconds). */
+export const DEFAULT_FETCH_TIMEOUT_MS = 60_000;
+const EXT_TO_MIME = {
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".jpeg": "image/jpeg",
+    ".webp": "image/webp",
+    ".gif": "image/gif",
+};
+export async function normalizeImageRef(ref) {
+    switch (ref.kind) {
+        case "bytes":
+            return { data: ref.data, mimeType: ref.mimeType };
+        case "base64":
+            return {
+                data: new Uint8Array(Buffer.from(ref.base64, "base64")),
+                mimeType: ref.mimeType,
+            };
+        case "path": {
+            const buf = await readFile(ref.path);
+            const ext = extname(ref.path).toLowerCase();
+            const inferred = EXT_TO_MIME[ext];
+            const mimeType = ref.mimeType ?? inferred;
+            if (!mimeType || !mimeType.startsWith("image/")) {
+                throw new Error(`Could not determine image MIME type for path "${ref.path}". ` +
+                    `Pass an explicit mimeType (e.g. "image/png") on the ImageRef.`);
+            }
+            return { data: new Uint8Array(buf), mimeType };
+        }
+        case "url": {
+            const timeoutMs = ref.timeoutMs ?? DEFAULT_FETCH_TIMEOUT_MS;
+            const res = await fetch(ref.url, {
+                signal: AbortSignal.timeout(timeoutMs),
+            });
+            if (!res.ok) {
+                throw new Error(`Failed to fetch image from ${ref.url}: ${res.status}`);
+            }
+            const buf = new Uint8Array(await res.arrayBuffer());
+            const contentType = res.headers.get("content-type") ?? undefined;
+            const mimeType = ref.mimeType ?? contentType;
+            if (!mimeType || !mimeType.startsWith("image/")) {
+                throw new Error(`Could not determine image MIME type for URL "${ref.url}". ` +
+                    `Response Content-Type was "${contentType ?? "missing"}". ` +
+                    `Pass an explicit mimeType (e.g. "image/png") on the ImageRef.`);
+            }
+            return { data: buf, mimeType };
+        }
+    }
+}

package/dist/util/provider.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Resolve the provider for a given model name.
+ * If an explicit provider is given, returns it directly.
+ * Otherwise looks up the model in the registry.
+ */
+export declare function resolveProvider(modelName: string, explicitProvider?: string): string;
+type ApiKeyConfig = {
+    openAiApiKey?: string;
+    googleApiKey?: string;
+    anthropicApiKey?: string;
+    ollamaApiKey?: string;
+};
+/**
+ * Resolve the API key for a provider, checking config then env vars.
+ */
+export declare function resolveApiKey(provider: string, config: ApiKeyConfig): string | undefined;
+export {};

package/dist/util/provider.js

@@ -0,0 +1,34 @@
+import { getModel } from "../models.js";
+import { SmolError } from "../smolError.js";
+/**
+ * Resolve the provider for a given model name.
+ * If an explicit provider is given, returns it directly.
+ * Otherwise looks up the model in the registry.
+ */
+export function resolveProvider(modelName, explicitProvider) {
+    if (explicitProvider)
+        return explicitProvider;
+    const model = getModel(modelName);
+    if (model === undefined) {
+        throw new SmolError(`Model ${modelName} is not recognized. Please specify a known model, or explicitly set the provider option in the config.`);
+    }
+    return model.provider;
+}
+/**
+ * Resolve the API key for a provider, checking config then env vars.
+ */
+export function resolveApiKey(provider, config) {
+    switch (provider) {
+        case "openai":
+        case "openai-responses":
+            return config.openAiApiKey || process.env.OPENAI_API_KEY;
+        case "google":
+            return config.googleApiKey || process.env.GEMINI_API_KEY;
+        case "anthropic":
+            return config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+        case "ollama":
+            return config.ollamaApiKey;
+        default:
+            return undefined;
+    }
+}

package/dist/util/util.d.ts

@@ -1,5 +1,28 @@
 export * from "./openai.js";
 export declare function round(num: number, places: number): number;
+/** Token-cost prices in the model registry are quoted per 1M tokens. */
+export declare const TOKENS_PER_MILLION = 1000000;
+/** Round all dollar costs to 6 decimal places (1/100 of a cent). */
+export declare const COST_DECIMAL_PLACES = 6;
+/**
+ * Compute the dollar cost of `tokens` at `costPerMillion` (USD per 1M tokens).
+ * Returns 0 if either argument is missing or non-positive.
+ */
+export declare function tokenCost(tokens: number | undefined, costPerMillion: number | undefined): number;
+/**
+ * Strip surrounding markdown code fences from a string. Returns the raw
+ * input unchanged if no fences are present. Handles both the leading
+ * ` ```json ` (case-insensitive, with optional trailing whitespace) and a
+ * trailing ` ``` ` on its own line. Useful when LLMs return JSON wrapped
+ * in markdown despite being asked for raw JSON.
+ */
+export declare function stripCodeFence(s: string): string;
+/**
+ * Return a shallow copy of `obj` with all `undefined` values stripped out.
+ * Useful when building request payloads where optional fields should only
+ * appear when explicitly set.
+ */
+export declare function omitUndefined<T extends Record<string, unknown>>(obj: T): T;
 /**
  * Sanitizes an object by removing keys that could cause prototype pollution.
  * Returns a shallow copy with dangerous keys filtered out.

package/dist/util/util.js

@@ -3,6 +3,46 @@ export function round(num, places) {
     const factor = Math.pow(10, places);
     return Math.round(num * factor) / factor;
 }
+/** Token-cost prices in the model registry are quoted per 1M tokens. */
+export const TOKENS_PER_MILLION = 1_000_000;
+/** Round all dollar costs to 6 decimal places (1/100 of a cent). */
+export const COST_DECIMAL_PLACES = 6;
+/**
+ * Compute the dollar cost of `tokens` at `costPerMillion` (USD per 1M tokens).
+ * Returns 0 if either argument is missing or non-positive.
+ */
+export function tokenCost(tokens, costPerMillion) {
+    if (!tokens || !costPerMillion || tokens <= 0)
+        return 0;
+    return round((tokens * costPerMillion) / TOKENS_PER_MILLION, COST_DECIMAL_PLACES);
+}
+/**
+ * Strip surrounding markdown code fences from a string. Returns the raw
+ * input unchanged if no fences are present. Handles both the leading
+ * ` ```json ` (case-insensitive, with optional trailing whitespace) and a
+ * trailing ` ``` ` on its own line. Useful when LLMs return JSON wrapped
+ * in markdown despite being asked for raw JSON.
+ */
+export function stripCodeFence(s) {
+    return s
+        .trim()
+        .replace(/^```(?:json)?\s*/i, "")
+        .replace(/\s*```\s*$/, "");
+}
+/**
+ * Return a shallow copy of `obj` with all `undefined` values stripped out.
+ * Useful when building request payloads where optional fields should only
+ * appear when explicitly set.
+ */
+export function omitUndefined(obj) {
+    const result = {};
+    for (const key of Object.keys(obj)) {
+        const value = obj[key];
+        if (value !== undefined)
+            result[key] = value;
+    }
+    return result;
+}
 const DANGEROUS_KEYS = new Set([
     "__proto__",
     "constructor",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "files": [
@@ -37,7 +37,7 @@
   },
   "scripts": {
     "test": "vitest --exclude=**/*.live.test.ts",
-    "test:live": "vitest run lib/clients/*.live.test.ts",
+    "test:live": "vitest run lib/clients/*.live.test.ts lib/embed/*.live.test.ts lib/image/*.live.test.ts",
     "test:tsc": "tsc -p tests/tsconfig.json",
     "build": "rm -rf dist && tsc",
     "start": "cd dist && node index.js",