smoltalk 0.6.0 → 0.7.0

package/dist/util/imageRef.js

@@ -1,4 +1,4 @@
-import { readFile } from "node:fs/promises";
+import { readFile, stat } 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;
@@ -8,8 +8,70 @@ const EXT_TO_MIME = {
     ".jpeg": "image/jpeg",
     ".webp": "image/webp",
     ".gif": "image/gif",
+    ".pdf": "application/pdf",
 };
-export async function normalizeImageRef(ref) {
+function isAllowedMime(mimeType, allowedPrefixes) {
+    for (const prefix of allowedPrefixes) {
+        if (mimeType.startsWith(prefix)) {
+            return true;
+        }
+    }
+    return false;
+}
+export async function normalizeImageRef(ref, options = {}) {
+    const allowed = options.allowedMimePrefixes ?? ["image/"];
+    const result = await loadRef(ref, allowed, options.maxBytes);
+    if (options.maxBytes !== undefined && result.data.length > options.maxBytes) {
+        throw new Error(`Attachment exceeds the maximum size of ${options.maxBytes} bytes ` +
+            `(got ${result.data.length} bytes).`);
+    }
+    if (!result.mimeType) {
+        throw new Error("internal: gated load returned no mimeType");
+    }
+    return { data: result.data, mimeType: result.mimeType };
+}
+/**
+ * Load a source to bytes WITHOUT the image MIME gate (used by file uploads,
+ * which accept any type). Enforces `maxBytes` across all kinds.
+ */
+export async function loadBlob(ref, options = {}) {
+    const result = await loadRef(ref, null, options.maxBytes);
+    if (options.maxBytes !== undefined && result.data.length > options.maxBytes) {
+        throw tooLargeError(options.maxBytes, result.data.length);
+    }
+    return result;
+}
+function tooLargeError(maxBytes, got) {
+    return new Error(`Attachment exceeds the maximum size of ${maxBytes} bytes (got ${got} bytes).`);
+}
+/**
+ * Read a response body into memory, aborting as soon as the running total
+ * exceeds `maxBytes` so a large or hostile URL can't exhaust memory. Falls back
+ * to buffering whole when the body isn't streamable.
+ */
+async function readBodyWithLimit(res, maxBytes) {
+    if (maxBytes === undefined || !res.body) {
+        return new Uint8Array(await res.arrayBuffer());
+    }
+    const reader = res.body.getReader();
+    const chunks = [];
+    let total = 0;
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done) {
+            break;
+        }
+        total += value.byteLength;
+        if (total > maxBytes) {
+            await reader.cancel();
+            throw tooLargeError(maxBytes, `>${total}`);
+        }
+        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));
+}
+async function loadRef(ref, allowed, maxBytes) {
     switch (ref.kind) {
         case "bytes":
             return { data: ref.data, mimeType: ref.mimeType };
@@ -19,31 +81,54 @@ export async function normalizeImageRef(ref) {
                 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);
+                }
+            }
             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.`);
+            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 ImageRef.`);
             }
             return { data: new Uint8Array(buf), mimeType };
         }
         case "url": {
+            // S2: only http(s) — reject file:/ftp:/gopher:/data: etc.
+            let scheme;
+            try {
+                scheme = new URL(ref.url).protocol;
+            }
+            catch {
+                throw new Error(`Invalid attachment URL: "${ref.url}".`);
+            }
+            if (scheme !== "http:" && scheme !== "https:") {
+                throw new Error(`Unsupported URL scheme "${scheme}" for attachment; only http(s) is allowed.`);
+            }
             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}`);
+                throw new Error(`Failed to fetch attachment from ${ref.url}: ${res.status}`);
+            }
+            // Reject on an honest Content-Length before reading a single byte of body.
+            const declaredLength = Number(res.headers.get("content-length"));
+            if (maxBytes !== undefined && declaredLength > maxBytes) {
+                throw tooLargeError(maxBytes, declaredLength);
             }
-            const buf = new Uint8Array(await res.arrayBuffer());
+            const buf = await readBodyWithLimit(res, maxBytes);
             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}". ` +
+            if (allowed !== null && (!mimeType || !isAllowedMime(mimeType, allowed))) {
+                throw new Error(`Could not determine an allowed MIME type for URL "${ref.url}". ` +
                     `Response Content-Type was "${contentType ?? "missing"}". ` +
-                    `Pass an explicit mimeType (e.g. "image/png") on the ImageRef.`);
+                    `Allowed: ${allowed.join(", ")}. Pass an explicit mimeType on the ImageRef.`);
             }
             return { data: buf, mimeType };
         }

package/dist/util/modalities.d.ts

@@ -0,0 +1,2 @@
+import { PromptResult, Result, SmolConfig } from "../types.js";
+export declare function validateModalities(config: SmolConfig): Result<PromptResult> | null;

package/dist/util/modalities.js

@@ -0,0 +1,31 @@
+import { UserMessage } from "../classes/message/index.js";
+import { modelSupportsInputModality } from "../models.js";
+import { failure } from "../types.js";
+export function validateModalities(config) {
+    let needsImage = false;
+    let needsPdf = false;
+    for (const msg of config.messages) {
+        if (!(msg instanceof UserMessage)) {
+            continue;
+        }
+        const parts = msg.getContentParts();
+        if (parts === null) {
+            continue;
+        }
+        for (const part of parts) {
+            if (part.type === "image") {
+                needsImage = true;
+            }
+            if (part.type === "file") {
+                needsPdf = true;
+            }
+        }
+    }
+    if (needsImage && modelSupportsInputModality(config.model, "image", config.modelData) === false) {
+        return failure(`Model ${config.model} does not support image input.`);
+    }
+    if (needsPdf && modelSupportsInputModality(config.model, "pdf", config.modelData) === false) {
+        return failure(`Model ${config.model} does not support PDF/document input.`);
+    }
+    return null;
+}

package/dist/util/redact.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Deep copy of `value` with attachment payloads (base64 / data URIs) replaced by
+ * a short summary, so logs and observability never carry large media blobs.
+ * Normal prose is left intact (only base64-shaped strings are summarized).
+ */
+export declare function redactAttachments(value: unknown): unknown;
+/** Replace every occurrence of a secret (e.g. an API key) in text with a marker. */
+export declare function redactSecret(text: string, secret?: string): string;

package/dist/util/redact.js

@@ -0,0 +1,42 @@
+const MAX_STRING = 2048;
+/**
+ * Deep copy of `value` with attachment payloads (base64 / data URIs) replaced by
+ * a short summary, so logs and observability never carry large media blobs.
+ * Normal prose is left intact (only base64-shaped strings are summarized).
+ */
+export function redactAttachments(value) {
+    if (typeof value === "string") {
+        return redactString(value);
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => redactAttachments(v));
+    }
+    if (value && typeof value === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(value)) {
+            out[k] = redactAttachments(v);
+        }
+        return out;
+    }
+    return value;
+}
+function redactString(s) {
+    const marker = ";base64,";
+    if (s.startsWith("data:") && s.includes(marker)) {
+        const prefix = s.slice(0, s.indexOf(marker) + marker.length);
+        return `${prefix}[redacted ${s.length} chars]`;
+    }
+    // A bare base64 payload is a single unbroken token. Requiring zero whitespace
+    // keeps prose (which has spaces) intact even when it's long and punctuation-free.
+    if (s.length > MAX_STRING && /^[A-Za-z0-9+/=]+$/.test(s)) {
+        return `[redacted ${s.length} base64 chars]`;
+    }
+    return s;
+}
+/** Replace every occurrence of a secret (e.g. an API key) in text with a marker. */
+export function redactSecret(text, secret) {
+    if (!secret) {
+        return text;
+    }
+    return text.split(secret).join("[redacted]");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "files": [