smoltalk 0.4.1 → 0.5.0

package/dist/util/httpError.js

@@ -0,0 +1,237 @@
+/**
+ * Explicit allowlist (not denylist, not prefix-wildcard). smoltalk can be
+ * pointed at proxies (LiteLLM, OpenRouter) that re-emit upstream headers
+ * verbatim, and some APIs echo credentials back on errors — a denylist would
+ * pass `authorization`, `x-api-key`, forwarded `llm_provider-*` headers, etc.
+ * (cf. Traefik GHSA-p6hg-qh38-555r). A prefix wildcard like `x-ratelimit-*`
+ * is safer than a denylist but still risks absorbing a future
+ * `x-ratelimit-organization` style header that carries an identifier or
+ * secret. Capture only known-safe headers with diagnostic value; the raw
+ * provider error is reachable on `SmolError.cause` (non-enumerable) as the
+ * escape hatch for callers that explicitly opt in.
+ */
+const ALLOWED_HEADERS = new Set([
+    // Retry hints
+    "retry-after",
+    "retry-after-ms",
+    // Request correlation
+    "request-id",
+    "x-request-id",
+    // Diagnostic
+    "content-type",
+    // OpenAI rate-limit family (exhaustive as of writing — new headers added
+    // by providers must be added explicitly here).
+    "x-ratelimit-limit-requests",
+    "x-ratelimit-limit-tokens",
+    "x-ratelimit-remaining-requests",
+    "x-ratelimit-remaining-tokens",
+    "x-ratelimit-reset-requests",
+    "x-ratelimit-reset-tokens",
+    // Anthropic rate-limit family
+    "anthropic-ratelimit-requests-limit",
+    "anthropic-ratelimit-requests-remaining",
+    "anthropic-ratelimit-requests-reset",
+    "anthropic-ratelimit-tokens-limit",
+    "anthropic-ratelimit-tokens-remaining",
+    "anthropic-ratelimit-tokens-reset",
+    "anthropic-ratelimit-input-tokens-limit",
+    "anthropic-ratelimit-input-tokens-remaining",
+    "anthropic-ratelimit-input-tokens-reset",
+    "anthropic-ratelimit-output-tokens-limit",
+    "anthropic-ratelimit-output-tokens-remaining",
+    "anthropic-ratelimit-output-tokens-reset",
+]);
+function isAllowedHeader(name) {
+    return ALLOWED_HEADERS.has(name.toLowerCase());
+}
+/**
+ * Upper bound on `retryAfterMs`. Anything longer is almost certainly a
+ * misparsed HTTP-date or a hostile/buggy proxy injecting a far-future value
+ * (e.g. `Sat, 01 Jan 9999 …`). 5 minutes is well beyond any sane provider
+ * rate-limit window — callers that wanted to wait longer would have given
+ * up by then anyway.
+ */
+const MAX_RETRY_AFTER_MS = 5 * 60 * 1000;
+function clampRetryAfter(ms) {
+    return Math.min(MAX_RETRY_AFTER_MS, Math.max(0, Math.round(ms)));
+}
+/**
+ * Read a property without letting a throwing accessor break the whole
+ * extraction. Some error shapes (especially JSON-parsed bodies that bubble
+ * up as errors) can carry getters that throw or have side effects.
+ */
+function safeGet(obj, key) {
+    try {
+        return obj[key];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function extractHttpErrorFields(error) {
+    const fields = {};
+    if (!error || typeof error !== "object") {
+        return fields;
+    }
+    const err = error;
+    const status = safeGet(err, "status") ??
+        safeGet(err, "statusCode") ??
+        safeGet(err, "status_code");
+    if (typeof status === "number") {
+        fields.status = status;
+    }
+    const headers = normalizeHeaders(safeGet(err, "headers"));
+    if (headers) {
+        fields.headers = headers;
+        const retryAfterMs = parseRetryAfterMs(headers);
+        if (retryAfterMs !== undefined) {
+            fields.retryAfterMs = retryAfterMs;
+        }
+    }
+    const requestId = extractRequestId(err, headers);
+    if (requestId !== undefined) {
+        fields.requestId = requestId;
+    }
+    return fields;
+}
+function extractRequestId(err, headers) {
+    // The OpenAI/Anthropic SDK errors carry a parsed request id directly.
+    // NOTE: providers may embed account/org identifiers in request ids (e.g.
+    // OpenAI's `req_<orghash>_<reqhash>`). These are loggable but not entirely
+    // opaque — keep that in mind when forwarding to third-party telemetry.
+    const requestID = safeGet(err, "requestID");
+    if (typeof requestID === "string") {
+        return requestID;
+    }
+    const request_id = safeGet(err, "request_id");
+    if (typeof request_id === "string") {
+        return request_id;
+    }
+    if (headers) {
+        return (headerValue(headers, "x-request-id") ?? headerValue(headers, "request-id"));
+    }
+    return undefined;
+}
+function normalizeHeaders(raw) {
+    if (!raw || typeof raw !== "object") {
+        return undefined;
+    }
+    const out = {};
+    // Web `Headers` (used by the OpenAI/Anthropic SDKs) is iterable via forEach.
+    // We always lowercase the stored key so downstream `headers["x-request-id"]`
+    // lookups work regardless of the provider's original casing.
+    try {
+        if (typeof raw.forEach === "function") {
+            raw.forEach((value, key) => {
+                if (isAllowedHeader(key)) {
+                    out[key.toLowerCase()] = value;
+                }
+            });
+        }
+        else {
+            // Fall back to a plain object of header key/value pairs.
+            for (const [key, value] of Object.entries(raw)) {
+                if (typeof value === "string" && isAllowedHeader(key)) {
+                    out[key.toLowerCase()] = value;
+                }
+            }
+        }
+    }
+    catch {
+        // A malformed Headers-shaped object with a throwing iterator — give up
+        // on header capture rather than poisoning the entire extraction.
+        return undefined;
+    }
+    return Object.keys(out).length > 0 ? out : undefined;
+}
+/**
+ * Parse a retry delay (in milliseconds) from the response headers, mirroring
+ * the logic the OpenAI and Anthropic SDKs use:
+ * 1. `retry-after-ms` (non-standard, ms precision) takes precedence.
+ * 2. Otherwise `retry-after` (RFC 9110): either delta-seconds or an HTTP-date.
+ *
+ * Always returns a non-negative value capped at `MAX_RETRY_AFTER_MS`.
+ */
+function parseRetryAfterMs(headers) {
+    // `retry-after-ms` (non-standard, OpenAI-specific) is always purely numeric;
+    // try whole-value first, then first-of-list, then give up.
+    const msRaw = headerValue(headers, "retry-after-ms");
+    const ms = numericHeader(msRaw) ?? numericHeader(firstNumericToken(msRaw));
+    if (ms !== undefined) {
+        return clampRetryAfter(ms);
+    }
+    const retryAfter = headerValue(headers, "retry-after");
+    if (retryAfter !== undefined) {
+        // 1. Try the whole value as a delta-seconds number ("30", "-3600").
+        const seconds = numericHeader(retryAfter);
+        if (seconds !== undefined) {
+            return clampRetryAfter(seconds * 1000);
+        }
+        // 2. Comma-separated numeric list? Take the first token if numeric.
+        //    NOTE: HTTP-dates contain commas ("Sat, 01 Jan ..."), so we only
+        //    take the first token when it parses as a pure number — otherwise
+        //    we'd mangle a perfectly good HTTP-date into "Sat".
+        const firstNumeric = numericHeader(firstNumericToken(retryAfter));
+        if (firstNumeric !== undefined) {
+            return clampRetryAfter(firstNumeric * 1000);
+        }
+        // 3. Otherwise treat as RFC 9110 HTTP-date.
+        const dateMs = Date.parse(retryAfter) - Date.now();
+        if (!Number.isNaN(dateMs)) {
+            return clampRetryAfter(dateMs);
+        }
+    }
+    return undefined;
+}
+/**
+ * Returns the first comma-separated token of `value` only if it parses as a
+ * number. Returns undefined for non-numeric first tokens (notably HTTP-dates
+ * like `"Sat, 01 Jan 2026 ..."`) so the caller can fall back to date parsing.
+ */
+function firstNumericToken(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const first = value.split(",")[0];
+    if (first === undefined) {
+        return undefined;
+    }
+    const trimmed = first.trim();
+    if (trimmed === "" || Number.isNaN(Number(trimmed))) {
+        return undefined;
+    }
+    return trimmed;
+}
+/**
+ * Strict numeric parse — unlike `parseFloat`, this rejects values with trailing
+ * junk (`"5xyz"`, `"30abc"`) instead of silently accepting a prefix.
+ */
+function numericHeader(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    if (trimmed === "") {
+        return undefined;
+    }
+    const parsed = Number(trimmed);
+    if (Number.isNaN(parsed)) {
+        return undefined;
+    }
+    return parsed;
+}
+function headerValue(headers, name) {
+    // Keys are stored lowercased by `normalizeHeaders`, so a direct lookup is
+    // sufficient. Keep a case-insensitive fallback for defense in depth in case
+    // a caller hands us a non-normalized object.
+    const lower = name.toLowerCase();
+    if (lower in headers) {
+        return headers[lower];
+    }
+    for (const [key, value] of Object.entries(headers)) {
+        if (key.toLowerCase() === lower) {
+            return value;
+        }
+    }
+    return undefined;
+}

package/dist/util/provider.d.ts

@@ -1,9 +1,10 @@
+import type { ModelDataBlob } from "../modelData.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 declare function resolveProvider(modelName: string, explicitProvider?: string): string;
+export declare function resolveProvider(modelName: string, explicitProvider?: string, modelData?: ModelDataBlob): string;
 type ApiKeyConfig = {
     openAiApiKey?: string;
     googleApiKey?: string;

package/dist/util/provider.js

@@ -5,10 +5,10 @@ import { SmolError } from "../smolError.js";
  * If an explicit provider is given, returns it directly.
  * Otherwise looks up the model in the registry.
  */
-export function resolveProvider(modelName, explicitProvider) {
+export function resolveProvider(modelName, explicitProvider, modelData) {
     if (explicitProvider)
         return explicitProvider;
-    const model = getModel(modelName);
+    const model = getModel(modelName, modelData);
     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.`);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "smoltalk",
-  "version": "0.4.1",
+  "version": "0.5.0",
   "description": "A common interface for LLM APIs",
   "homepage": "https://github.com/egonSchiele/smoltalk",
   "files": [
@@ -35,6 +35,9 @@
     "openai": "^6.15.0",
     "zod": "^4.3.6"
   },
+  "devDependencies": {
+    "tsx": "^4.19.2"
+  },
   "scripts": {
     "test": "vitest --exclude=**/*.live.test.ts",
     "test:live": "vitest run lib/clients/*.live.test.ts lib/embed/*.live.test.ts lib/image/*.live.test.ts",
@@ -42,6 +45,8 @@
     "build": "rm -rf dist && tsc",
     "start": "cd dist && node index.js",
     "doc": "typedoc --disableSources --out docs lib && prettier docs/ --write",
-    "typecheck": "tsc --noEmit"
+    "typecheck": "tsc --noEmit",
+    "seed-data": "tsx scripts/seed-model-data.ts",
+    "refresh-data": "tsx scripts/refresh-from-modelsdev.ts"
   }
 }