smoltalk 0.15.3 → 0.17.0

package/dist/platform.browser.d.ts

@@ -0,0 +1,5 @@
+import type { Platform } from "./platform.js";
+export declare const readFileBytes: Platform["readFileBytes"];
+export declare const readTextFromFileUrl: Platform["readTextFromFileUrl"];
+export declare const pathToFileUrl: Platform["pathToFileUrl"];
+export declare const env: Platform["env"];

package/dist/platform.browser.js

@@ -0,0 +1,13 @@
+function unavailable(fn) {
+    return new Error(`${fn} is not available in a browser build of smoltalk.`);
+}
+export const readFileBytes = async () => {
+    throw unavailable("readFileBytes");
+};
+export const readTextFromFileUrl = async () => {
+    throw unavailable("readTextFromFileUrl");
+};
+export const pathToFileUrl = () => {
+    throw unavailable("pathToFileUrl");
+};
+export const env = () => undefined;

package/dist/platform.d.ts

@@ -0,0 +1,33 @@
+/**
+ * The functions smoltalk takes from the platform it runs on. Two files
+ * implement them, `platform.node.ts` and `platform.browser.ts`, and the
+ * `#platform` entry in package.json's `imports` picks one: Node resolves
+ * it to the Node file, and a bundler run with its browser condition
+ * (esbuild `--platform=browser`, Vite, webpack `target: "web"`) picks the
+ * browser file. Shared code imports `#platform` and never `node:*`.
+ *
+ * The browser file throws from every file function and answers `undefined`
+ * for every environment variable, so a browser caller passes API keys in
+ * and cannot use path attachments, `file:` model data, or the llama.cpp
+ * loader's `entryPath`. Pure string work such as a path's extension is not
+ * on the platform; see `lib/util/fileExtension.ts`.
+ */
+export type Platform = {
+    /** The bytes of the file at `path`. With `maxBytes`, refuses a larger
+     *  file before reading it, with a {@link FileTooLargeError}. */
+    readFileBytes(path: string, maxBytes?: number): Promise<Uint8Array>;
+    /** The text of the file a `file:` URL names, as UTF-8. */
+    readTextFromFileUrl(url: string): Promise<string>;
+    /** The `file:` URL for a file system path. */
+    pathToFileUrl(path: string): string;
+    /** The environment variable `name`, or `undefined` when unset or when
+     *  the platform has no environment. */
+    env(name: string): string | undefined;
+};
+/** Thrown by `readFileBytes` when the file is larger than `maxBytes`. */
+export declare class FileTooLargeError extends Error {
+    readonly path: string;
+    readonly size: number;
+    readonly maxBytes: number;
+    constructor(path: string, size: number, maxBytes: number);
+}

package/dist/platform.js

@@ -0,0 +1,13 @@
+/** Thrown by `readFileBytes` when the file is larger than `maxBytes`. */
+export class FileTooLargeError extends Error {
+    path;
+    size;
+    maxBytes;
+    constructor(path, size, maxBytes) {
+        super(`File ${path} is ${size} bytes, over the limit of ${maxBytes} bytes.`);
+        this.path = path;
+        this.size = size;
+        this.maxBytes = maxBytes;
+        this.name = "FileTooLargeError";
+    }
+}

package/dist/platform.node.d.ts

@@ -0,0 +1,5 @@
+import { type Platform } from "./platform.js";
+export declare const readFileBytes: Platform["readFileBytes"];
+export declare const readTextFromFileUrl: Platform["readTextFromFileUrl"];
+export declare const pathToFileUrl: Platform["pathToFileUrl"];
+export declare const env: Platform["env"];

package/dist/platform.node.js

@@ -0,0 +1,17 @@
+// The Node side of #platform. See platform.ts.
+import { readFile, stat } from "node:fs/promises";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { FileTooLargeError } from "./platform.js";
+export const readFileBytes = async (path, maxBytes) => {
+    if (maxBytes !== undefined) {
+        const info = await stat(path);
+        if (info.size > maxBytes) {
+            throw new FileTooLargeError(path, info.size, maxBytes);
+        }
+    }
+    const buf = await readFile(path);
+    return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+};
+export const readTextFromFileUrl = (url) => readFile(fileURLToPath(url), "utf8");
+export const pathToFileUrl = (path) => pathToFileURL(path).href;
+export const env = (name) => process.env[name];

package/dist/speech/google.js

@@ -1,3 +1,4 @@
+import { base64ToBytes } from "../util/base64.js";
 import { GoogleGenAI } from "@google/genai";
 import { success, failure } from "../types/result.js";
 import { pcmToWav } from "../util/audioMime.js";
@@ -36,7 +37,7 @@ export class GoogleSpeechClient extends BaseSpeechClient {
         if (!dataB64) {
             return failure("Gemini returned no audio data.");
         }
-        const pcm = new Uint8Array(Buffer.from(dataB64, "base64"));
+        const pcm = base64ToBytes(dataB64);
         let audio = pcm;
         let mimeType = "application/octet-stream";
         if (format === "wav") {

package/dist/speech/groq.js

@@ -6,6 +6,7 @@ import { OpenAISpeechClient } from "./openai.js";
 export class GroqSpeechClient extends OpenAISpeechClient {
     makeClient() {
         return new OpenAI({
+            dangerouslyAllowBrowser: true,
             apiKey: this.config.apiKey,
             baseURL: "https://api.groq.com/openai/v1",
         });

package/dist/speech/mlx.js

@@ -21,6 +21,7 @@ export class MlxSpeechClient extends OpenAISpeechClient {
         const baseURL = resolveBaseUrl("mlx", { baseUrl: this.config.baseUrl });
         // The OpenAI SDK refuses an empty key. The local server never reads it.
         return new OpenAI({
+            dangerouslyAllowBrowser: true,
             apiKey: "mlx-local",
             baseURL,
             maxRetries: 0,

package/dist/speech/openai.js

@@ -5,7 +5,7 @@ import { BaseSpeechClient } from "./baseSpeechClient.js";
 export class OpenAISpeechClient extends BaseSpeechClient {
     /** Build the OpenAI SDK client. Subclasses override to point at a compatible base URL. */
     makeClient() {
-        return new OpenAI({ apiKey: this.config.apiKey });
+        return new OpenAI({ dangerouslyAllowBrowser: true, apiKey: this.config.apiKey });
     }
     /** Provider default used when the declarative call omits format. */
     defaultFormat() {

package/dist/speech/openaiCompat.js

@@ -14,7 +14,7 @@ export class OpenAiCompatSpeechClient extends OpenAISpeechClient {
         if (!baseURL) {
             throw new Error("openai-compat: base URL required (config.baseUrl.openAiCompat or OPENAI_COMPAT_BASE_URL).");
         }
-        return new OpenAI({ apiKey: this.config.apiKey, baseURL });
+        return new OpenAI({ dangerouslyAllowBrowser: true, apiKey: this.config.apiKey, baseURL });
     }
     noKeyMessage() {
         return "No API key provided. Set apiKey.openAiCompat or OPENAI_COMPAT_API_KEY.";

package/dist/statelogClient.js

@@ -1,3 +1,4 @@
+import { env } from "#platform";
 import { nanoid } from "nanoid";
 import { failure, mergeResults, success } from "./types/result.js";
 import { redactAttachments } from "./util/redact.js";
@@ -311,7 +312,7 @@ export function getStatelogClient(config) {
     const statelogConfig = {
         host: config.host,
         traceId: config.traceId || nanoid(),
-        apiKey: process.env.STATELOG_SMOLTALK_API_KEY || "",
+        apiKey: env("STATELOG_SMOLTALK_API_KEY") || "",
         projectId: config.projectId,
         debugMode: config.debugMode || false,
     };

package/dist/transcription/google.js

@@ -1,3 +1,4 @@
+import { bytesToBase64, utf8ByteLength } from "../util/base64.js";
 import { GoogleGenAI } from "@google/genai";
 import { success, failure } from "../types/result.js";
 import { BaseTranscriptionClient } from "./baseTranscriptionClient.js";
@@ -22,7 +23,7 @@ export class GoogleTranscriptionClient extends BaseTranscriptionClient {
         if (this.config.prompt) {
             instruction += ` ${this.config.prompt}`;
         }
-        const base64 = Buffer.from(data).toString("base64");
+        const base64 = bytesToBase64(data);
         const request = {
             model: this.config.model,
             contents: [{
@@ -33,7 +34,7 @@ export class GoogleTranscriptionClient extends BaseTranscriptionClient {
                     ],
                 }],
         };
-        if (Buffer.byteLength(JSON.stringify(request), "utf8") > GOOGLE_INLINE_REQUEST_MAX_BYTES) {
+        if (utf8ByteLength(JSON.stringify(request)) > GOOGLE_INLINE_REQUEST_MAX_BYTES) {
             return failure("Audio and instructions exceed Gemini's 20 MB inline request limit; use a smaller source.");
         }
         const ai = new GoogleGenAI({ apiKey: this.config.apiKey });

package/dist/transcription/groq.js

@@ -7,6 +7,7 @@ import { OpenAITranscriptionClient } from "./openai.js";
 export class GroqTranscriptionClient extends OpenAITranscriptionClient {
     makeClient() {
         return new OpenAI({
+            dangerouslyAllowBrowser: true,
             apiKey: this.config.apiKey,
             baseURL: "https://api.groq.com/openai/v1",
         });

package/dist/transcription/openai.js

@@ -5,7 +5,7 @@ import { BaseTranscriptionClient } from "./baseTranscriptionClient.js";
 export class OpenAITranscriptionClient extends BaseTranscriptionClient {
     /** Build the OpenAI SDK client. Subclasses override to point at a compatible base URL. */
     makeClient() {
-        return new OpenAI({ apiKey: this.config.apiKey });
+        return new OpenAI({ dangerouslyAllowBrowser: true, apiKey: this.config.apiKey });
     }
     /** Provider-specific diagnostic when no API key is resolved. Subclasses override. */
     noKeyMessage() {

package/dist/transcription/openaiCompat.js

@@ -14,7 +14,7 @@ export class OpenAiCompatTranscriptionClient extends OpenAITranscriptionClient {
         if (!baseURL) {
             throw new Error("openai-compat: base URL required (config.baseUrl.openAiCompat or OPENAI_COMPAT_BASE_URL).");
         }
-        return new OpenAI({ apiKey: this.config.apiKey, baseURL });
+        return new OpenAI({ dangerouslyAllowBrowser: true, apiKey: this.config.apiKey, baseURL });
     }
     noKeyMessage() {
         return "No API key provided. Set apiKey.openAiCompat or OPENAI_COMPAT_API_KEY.";

package/dist/types.d.ts

@@ -119,6 +119,12 @@ export type SmolConfig = {
         strict: boolean;
         numRetries: number;
         allowExtraKeys: boolean;
+        /** Local providers (`mlx`, `llama-cpp`) cannot enforce a schema on a
+         *  request that carries tools, so a call with both is made as two
+         *  requests: the tool round first, then the reply in the schema. Set
+         *  this to `false` to send one request and leave the schema unenforced.
+         *  Defaults to `true`. Google always makes two requests. */
+        separateFromTools: boolean;
     }>;
     /** Arbitrary provider-specific attributes passed directly to the underlying API call. */
     rawAttributes?: Record<string, any>;

package/dist/util/attachments.js

@@ -1,3 +1,4 @@
+import { bytesToBase64 } from "./base64.js";
 /** Filename sent to providers that require one when a file part omits its own. */
 export const DEFAULT_ATTACHMENT_FILENAME = "attachment.pdf";
 /** A file part's filename, falling back to the shared default when unset. */
@@ -17,7 +18,7 @@ export function refToBase64(ref) {
         return { base64: ref.base64, mimeType: ref.mimeType };
     }
     if (ref.kind === "bytes") {
-        return { base64: Buffer.from(ref.data).toString("base64"), mimeType: ref.mimeType };
+        return { base64: bytesToBase64(ref.data), mimeType: ref.mimeType };
     }
     throw new Error(`Attachment ref must be resolved to base64 or bytes before serialization ` +
         `(got kind="${ref.kind}"). This is a smoltalk bug.`);

package/dist/util/base64.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Bytes to and from base64, and two other byte helpers, written without
+ * `Buffer` so they run in a browser. `Uint8Array.fromBase64` and
+ * `toBase64` are used where the runtime has them, and `atob`/`btoa` with a
+ * loop elsewhere.
+ */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+/**
+ * Decodes standard base64 and base64url (`-` and `_` for `+` and `/`),
+ * with or without padding. Any other character throws. `Buffer`, which
+ * this replaced, skipped characters it did not know.
+ */
+export declare function base64ToBytes(text: string): Uint8Array;
+/** One array holding every chunk in order. */
+export declare function concatBytes(chunks: Uint8Array[], total?: number): Uint8Array;
+/** The number of bytes `text` takes as UTF-8. */
+export declare function utf8ByteLength(text: string): number;

package/dist/util/base64.js

@@ -0,0 +1,59 @@
+/**
+ * Bytes to and from base64, and two other byte helpers, written without
+ * `Buffer` so they run in a browser. `Uint8Array.fromBase64` and
+ * `toBase64` are used where the runtime has them, and `atob`/`btoa` with a
+ * loop elsewhere.
+ */
+export function bytesToBase64(bytes) {
+    const native = bytes.toBase64;
+    if (typeof native === "function") {
+        return native.call(bytes);
+    }
+    let binary = "";
+    const chunk = 0x8000;
+    for (let i = 0; i < bytes.length; i += chunk) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + chunk));
+    }
+    return btoa(binary);
+}
+/**
+ * Decodes standard base64 and base64url (`-` and `_` for `+` and `/`),
+ * with or without padding. Any other character throws. `Buffer`, which
+ * this replaced, skipped characters it did not know.
+ */
+export function base64ToBytes(text) {
+    if (text.includes("-") || text.includes("_")) {
+        text = text.replace(/-/g, "+").replace(/_/g, "/");
+    }
+    const native = Uint8Array.fromBase64;
+    if (typeof native === "function") {
+        return native.call(Uint8Array, text);
+    }
+    const binary = atob(text);
+    const out = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+        out[i] = binary.charCodeAt(i);
+    }
+    return out;
+}
+/** One array holding every chunk in order. */
+export function concatBytes(chunks, total) {
+    let length = total;
+    if (length === undefined) {
+        length = 0;
+        for (const chunk of chunks) {
+            length += chunk.byteLength;
+        }
+    }
+    const out = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    return out;
+}
+/** The number of bytes `text` takes as UTF-8. */
+export function utf8ByteLength(text) {
+    return new TextEncoder().encode(text).byteLength;
+}

package/dist/util/blobRef.js

@@ -1,5 +1,7 @@
-import { readFile, stat } from "node:fs/promises";
-import { extname } from "node:path";
+import { readFileBytes } from "#platform";
+import { FileTooLargeError } from "../platform.js";
+import { base64ToBytes, concatBytes } from "./base64.js";
+import { fileExtension } from "./fileExtension.js";
 import { EXT_TO_MIME } from "./mime.js";
 /** Default timeout for fetching attachment URLs during normalization (60 seconds). */
 export const DEFAULT_FETCH_TIMEOUT_MS = 60_000;
@@ -62,7 +64,7 @@ async function readBodyWithLimit(res, maxBytes) {
         chunks.push(value);
     }
     // Pass the known total so concat doesn't re-scan the chunk list for its length.
-    return new Uint8Array(Buffer.concat(chunks, total));
+    return concatBytes(chunks, total);
 }
 async function loadRef(ref, allowed, maxBytes) {
     switch (ref.kind) {
@@ -70,26 +72,30 @@ async function loadRef(ref, allowed, maxBytes) {
             return { data: ref.data, mimeType: ref.mimeType };
         case "base64":
             return {
-                data: new Uint8Array(Buffer.from(ref.base64, "base64")),
+                data: base64ToBytes(ref.base64),
                 mimeType: ref.mimeType,
             };
         case "path": {
-            // S1: bound memory — reject on stat before reading the whole file.
-            if (maxBytes !== undefined) {
-                const info = await stat(ref.path);
-                if (info.size > maxBytes) {
-                    throw tooLargeError(maxBytes, info.size);
+            // S1: bound memory — readFileBytes rejects on the file's size before
+            // reading it. In a browser it throws: there is no file system.
+            let buf;
+            try {
+                buf = await readFileBytes(ref.path, maxBytes);
+            }
+            catch (err) {
+                if (err instanceof FileTooLargeError) {
+                    throw tooLargeError(err.maxBytes, err.size);
                 }
+                throw err;
             }
-            const buf = await readFile(ref.path);
-            const ext = extname(ref.path).toLowerCase();
+            const ext = fileExtension(ref.path);
             const inferred = EXT_TO_MIME[ext];
             const mimeType = ref.mimeType ?? inferred;
             if (allowed !== null && (!mimeType || !isAllowedMime(mimeType, allowed))) {
                 throw new Error(`Could not determine an allowed MIME type for path "${ref.path}". ` +
                     `Allowed: ${allowed.join(", ")}. Pass an explicit mimeType on the BlobRef.`);
             }
-            return { data: new Uint8Array(buf), mimeType };
+            return { data: buf, mimeType };
         }
         case "url": {
             // S2: only http(s) — reject file:/ftp:/gopher:/data: etc.

package/dist/util/fileExtension.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The extension of a path including its dot, lower-cased, or "" when there
+ * is none. Follows Node's `path.extname`: only the last segment counts, a
+ * leading dot (`.bashrc`) is not an extension, and a trailing dot gives ".", and ".." gives "".
+ * String work only, so it is the same on every platform.
+ */
+export declare function fileExtension(path: string): string;

package/dist/util/fileExtension.js

@@ -0,0 +1,15 @@
+/**
+ * The extension of a path including its dot, lower-cased, or "" when there
+ * is none. Follows Node's `path.extname`: only the last segment counts, a
+ * leading dot (`.bashrc`) is not an extension, and a trailing dot gives ".", and ".." gives "".
+ * String work only, so it is the same on every platform.
+ */
+export function fileExtension(path) {
+    const slash = Math.max(path.lastIndexOf("/"), path.lastIndexOf("\\"));
+    const base = path.slice(slash + 1);
+    const dot = base.lastIndexOf(".");
+    if (dot <= 0 || base === "..") {
+        return "";
+    }
+    return base.slice(dot).toLowerCase();
+}

package/dist/util/provider.d.ts

@@ -36,6 +36,7 @@ type NestedKeyConfig = {
 };
 /**
  * Resolve the API key for a provider, checking config then env vars.
+ * In a browser `env` answers nothing, so the caller passes the key.
  */
 export declare function resolveApiKey(provider: string, config: NestedKeyConfig): string | undefined;
 /**

package/dist/util/provider.js

@@ -1,3 +1,4 @@
+import { env } from "#platform";
 import { getModel } from "../models.js";
 import { SmolError } from "../smolError.js";
 /**
@@ -16,31 +17,32 @@ export function resolveProvider(modelName, explicitProvider, modelData) {
 }
 /**
  * Resolve the API key for a provider, checking config then env vars.
+ * In a browser `env` answers nothing, so the caller passes the key.
  */
 export function resolveApiKey(provider, config) {
     const k = config.apiKey;
     switch (provider) {
         case "openai":
         case "openai-responses":
-            return k?.openAi || process.env.OPENAI_API_KEY;
+            return k?.openAi || env("OPENAI_API_KEY");
         case "google":
-            return k?.google || process.env.GEMINI_API_KEY;
+            return k?.google || env("GEMINI_API_KEY");
         case "anthropic":
-            return k?.anthropic || process.env.ANTHROPIC_API_KEY;
+            return k?.anthropic || env("ANTHROPIC_API_KEY");
         case "ollama":
             return k?.ollama;
         case "openrouter":
-            return k?.openRouter || process.env.OPENROUTER_API_KEY;
+            return k?.openRouter || env("OPENROUTER_API_KEY");
         case "deepinfra":
-            return k?.deepInfra || process.env.DEEPINFRA_API_KEY;
+            return k?.deepInfra || env("DEEPINFRA_API_KEY");
         case "litellm":
-            return k?.liteLlm || process.env.LITELLM_API_KEY;
+            return k?.liteLlm || env("LITELLM_API_KEY");
         case "openai-compat":
-            return k?.openAiCompat || process.env.OPENAI_COMPAT_API_KEY;
+            return k?.openAiCompat || env("OPENAI_COMPAT_API_KEY");
         case "groq":
-            return k?.groq || process.env.GROQ_API_KEY;
+            return k?.groq || env("GROQ_API_KEY");
         case "typesafe":
-            return k?.typesafe || process.env.TYPESAFE_API_KEY;
+            return k?.typesafe || env("TYPESAFE_API_KEY");
         default:
             return config.apiKey?.[provider];
     }
@@ -57,20 +59,20 @@ export function resolveBaseUrl(provider, config) {
     const b = config.baseUrl;
     switch (provider) {
         case "ollama":
-            return b?.ollama || process.env.OLLAMA_HOST;
+            return b?.ollama || env("OLLAMA_HOST");
         case "openrouter":
             return b?.openRouter || "https://openrouter.ai/api/v1";
         case "deepinfra":
             return b?.deepInfra || "https://api.deepinfra.com/v1/openai";
         case "litellm":
-            return b?.liteLlm || process.env.LITELLM_BASE_URL;
+            return b?.liteLlm || env("LITELLM_BASE_URL");
         case "openai-compat":
-            return b?.openAiCompat || process.env.OPENAI_COMPAT_BASE_URL;
+            return b?.openAiCompat || env("OPENAI_COMPAT_BASE_URL");
         case "mlx":
-            return b?.mlx || process.env.MLX_BASE_URL || "http://127.0.0.1:8080/v1";
+            return b?.mlx || env("MLX_BASE_URL") || "http://127.0.0.1:8080/v1";
         case "typesafe":
             // A Laya server (`laya-serve`) speaks the same protocol; point this at it.
-            return b?.typesafe || process.env.TYPESAFE_BASE_URL || "https://api.typesafe.ai";
+            return b?.typesafe || env("TYPESAFE_BASE_URL") || "https://api.typesafe.ai";
         default:
             return undefined;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.15.3",
+  "version": "0.17.0",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "files": [
@@ -23,6 +23,16 @@
       "require": "./dist/testing/index.js"
     }
   },
+  "imports": {
+    "#platform": {
+      "browser": "./dist/platform.browser.js",
+      "default": "./dist/platform.node.js"
+    },
+    "#ollama": {
+      "browser": "ollama/browser",
+      "default": "ollama"
+    }
+  },
   "type": "module",
   "types": "./dist/index.d.ts",
   "keywords": [
@@ -41,6 +51,7 @@
     "zod": "^4.4.3"
   },
   "devDependencies": {
+    "esbuild": "^0.28.2",
     "tsx": "^4.19.2"
   },
   "peerDependencies": {
@@ -60,6 +71,7 @@
     "doc": "typedoc --disableSources --out docs lib && prettier docs/ --write",
     "typecheck": "tsc --noEmit",
     "seed-data": "tsx scripts/seed-model-data.ts",
-    "refresh-data": "tsx scripts/refresh-from-modelsdev.ts"
+    "refresh-data": "tsx scripts/refresh-from-modelsdev.ts",
+    "check:browser": "node scripts/check-browser-bundle.mjs"
   }
 }