smoltalk 0.5.1 → 0.7.0

package/dist/clients/resolveAttachments.js

@@ -0,0 +1,108 @@
+import { UserMessage } from "../classes/message/index.js";
+import { normalizeImageRef } from "../util/imageRef.js";
+import { fileFamily } from "../util/attachments.js";
+import { success, failure } from "../types.js";
+export const DEFAULT_MAX_ATTACHMENT_BYTES = 20 * 1024 * 1024;
+const URL_IMAGE_PROVIDERS = new Set([
+    "openai",
+    "openai-responses",
+    "openai-compat",
+    "openrouter",
+    "deepinfra",
+    "litellm",
+    "anthropic",
+]);
+const URL_PDF_PROVIDERS = new Set(["openai-responses", "anthropic"]);
+/** Whether any user message carries an image/file attachment part. */
+export function messagesHaveAttachments(messages) {
+    for (const msg of messages) {
+        if (!(msg instanceof UserMessage)) {
+            continue;
+        }
+        const parts = msg.getContentParts();
+        if (parts === null) {
+            continue;
+        }
+        for (const part of parts) {
+            if (part.type === "image" || part.type === "file") {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/** Whether `provider` accepts a remote URL directly for this part type. */
+export function acceptsRemoteUrl(provider, partType) {
+    if (partType === "image") {
+        return URL_IMAGE_PROVIDERS.has(provider);
+    }
+    return URL_PDF_PROVIDERS.has(provider);
+}
+export async function resolveMessageAttachments(messages, options) {
+    const out = [];
+    for (const msg of messages) {
+        if (!(msg instanceof UserMessage)) {
+            out.push(msg);
+            continue;
+        }
+        const parts = msg.getContentParts();
+        if (parts === null) {
+            out.push(msg);
+            continue;
+        }
+        const resolvedParts = [];
+        for (const part of parts) {
+            if (part.type === "text") {
+                resolvedParts.push(part);
+                continue;
+            }
+            // Provider file references are validated and passed through (no download/cap).
+            if (part.source.kind === "providerFile") {
+                const family = fileFamily(options.provider);
+                if (family === null || part.source.provider !== family) {
+                    return failure(`Attachment references a "${part.source.provider}" file, but this call targets provider ` +
+                        `"${options.provider}" (file family ${family ?? "none"}).`);
+                }
+                if (part.type === "image" && options.provider === "openai") {
+                    return failure("An image file reference requires the openai-responses provider (OpenAI Chat Completions has no image-by-file_id form).");
+                }
+                resolvedParts.push(part);
+                continue;
+            }
+            // Passthrough: keep a url ref when the target provider accepts a remote URL.
+            if (part.source.kind === "url" && acceptsRemoteUrl(options.provider, part.type)) {
+                resolvedParts.push(part);
+                continue;
+            }
+            let allowed;
+            if (part.type === "image") {
+                allowed = ["image/"];
+            }
+            else {
+                allowed = ["application/pdf"];
+            }
+            try {
+                const { data, mimeType } = await normalizeImageRef(part.source, {
+                    allowedMimePrefixes: allowed,
+                    maxBytes: options.maxBytes,
+                });
+                const source = {
+                    kind: "base64",
+                    base64: Buffer.from(data).toString("base64"),
+                    mimeType,
+                };
+                if (part.type === "image") {
+                    resolvedParts.push({ type: "image", source });
+                }
+                else {
+                    resolvedParts.push({ type: "file", source, filename: part.filename });
+                }
+            }
+            catch (err) {
+                return failure(`Failed to load ${part.type} attachment: ${err.message}`);
+            }
+        }
+        out.push(new UserMessage(resolvedParts, { name: msg.name, rawData: msg.rawData }));
+    }
+    return success(out);
+}

package/dist/embed/openai.d.ts

@@ -1,3 +1,9 @@
 import { EmbedConfig, EmbedResult } from "../embed.js";
 import { Result } from "../types/result.js";
-export declare function openaiEmbed(inputs: string[], config: EmbedConfig, apiKey: string): Promise<Result<EmbedResult>>;
+/**
+ * OpenAI-compatible embedding call. Used by openai directly and by other
+ * OpenAI-shape backends (deepinfra, litellm, openai-compat) which pass a
+ * custom `baseURL`. Cost comes from the smoltalk model registry; provider-
+ * returned cost fields aren't standardized on this endpoint.
+ */
+export declare function openaiEmbed(inputs: string[], config: EmbedConfig, apiKey: string, baseURL?: string): Promise<Result<EmbedResult>>;

package/dist/embed/openai.js

@@ -2,9 +2,15 @@ import OpenAI from "openai";
 import { success, failure } from "../types/result.js";
 import { getModel, isEmbeddingsModel } from "../models.js";
 import { round } from "../util/util.js";
-export async function openaiEmbed(inputs, config, apiKey) {
+/**
+ * OpenAI-compatible embedding call. Used by openai directly and by other
+ * OpenAI-shape backends (deepinfra, litellm, openai-compat) which pass a
+ * custom `baseURL`. Cost comes from the smoltalk model registry; provider-
+ * returned cost fields aren't standardized on this endpoint.
+ */
+export async function openaiEmbed(inputs, config, apiKey, baseURL) {
     try {
-        const client = new OpenAI({ apiKey });
+        const client = new OpenAI({ apiKey, ...(baseURL ? { baseURL } : {}) });
         const response = await client.embeddings.create({
             model: config.model,
             input: inputs,

package/dist/embed.d.ts

@@ -6,10 +6,24 @@ export type EmbedConfig = {
     model: string;
     provider?: string;
     dimensions?: number;
-    openAiApiKey?: string;
-    googleApiKey?: string;
-    ollamaApiKey?: string;
-    ollamaHost?: string;
+    /** API keys, nested by provider. Falls back to env vars
+     *  (OPENAI_API_KEY / GEMINI_API_KEY / DEEPINFRA_API_KEY /
+     *  LITELLM_API_KEY / OPENAI_COMPAT_API_KEY). */
+    apiKey?: {
+        openAi?: string;
+        google?: string;
+        ollama?: string;
+        deepInfra?: string;
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
+    /** Custom base URLs, nested by provider. */
+    baseUrl?: {
+        ollama?: string;
+        deepInfra?: string;
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
     metadata?: Record<string, unknown>;
     modelData?: ModelDataBlob;
 };

package/dist/embed.js

@@ -1,5 +1,5 @@
 import { failure } from "./types/result.js";
-import { resolveProvider, resolveApiKey } from "./util/provider.js";
+import { resolveProvider, resolveApiKey, resolveBaseUrl } from "./util/provider.js";
 import { openaiEmbed } from "./embed/openai.js";
 import { googleEmbed } from "./embed/google.js";
 import { ollamaEmbed } from "./embed/ollama.js";
@@ -23,18 +23,46 @@ export async function embed(input, config) {
         case "openai":
         case "openai-responses": {
             if (!apiKey) {
-                return failure("No OpenAI API key provided. Set openAiApiKey in config or the OPENAI_API_KEY environment variable.");
+                return failure("No OpenAI API key provided. Set config.apiKey.openAi or the OPENAI_API_KEY environment variable.");
             }
             return openaiEmbed(inputs, config, apiKey);
         }
         case "google": {
             if (!apiKey) {
-                return failure("No Google API key provided. Set googleApiKey in config or the GEMINI_API_KEY environment variable.");
+                return failure("No Google API key provided. Set config.apiKey.google or the GEMINI_API_KEY environment variable.");
             }
             return googleEmbed(inputs, config, apiKey);
         }
         case "ollama":
-            return ollamaEmbed(inputs, config, apiKey, config.ollamaHost);
+            return ollamaEmbed(inputs, config, apiKey, resolveBaseUrl("ollama", config));
+        case "openrouter":
+            return failure("openrouter does not expose an embeddings endpoint; use deepinfra, openai-compat, or litellm instead.");
+        case "deepinfra": {
+            if (!apiKey) {
+                return failure("No DeepInfra API key provided. Set config.apiKey.deepInfra or the DEEPINFRA_API_KEY environment variable.");
+            }
+            return openaiEmbed(inputs, config, apiKey, resolveBaseUrl("deepinfra", config));
+        }
+        case "litellm": {
+            if (!apiKey) {
+                return failure("No LiteLLM API key provided. Set config.apiKey.liteLlm or the LITELLM_API_KEY environment variable.");
+            }
+            const baseURL = resolveBaseUrl("litellm", config);
+            if (!baseURL) {
+                return failure("No LiteLLM base URL provided. Set config.baseUrl.liteLlm or the LITELLM_BASE_URL environment variable.");
+            }
+            return openaiEmbed(inputs, config, apiKey, baseURL);
+        }
+        case "openai-compat": {
+            if (!apiKey) {
+                return failure("No openai-compat API key provided. Set config.apiKey.openAiCompat or the OPENAI_COMPAT_API_KEY environment variable.");
+            }
+            const baseURL = resolveBaseUrl("openai-compat", config);
+            if (!baseURL) {
+                return failure("No openai-compat base URL provided. Set config.baseUrl.openAiCompat or the OPENAI_COMPAT_BASE_URL environment variable.");
+            }
+            return openaiEmbed(inputs, config, apiKey, baseURL);
+        }
         default: {
             const custom = registeredEmbedProviders[provider];
             if (custom) {

package/dist/files/BaseFileProvider.d.ts

@@ -0,0 +1,29 @@
+import type { FileProvider, FileProviderContext } from "../files.js";
+import type { ProviderFileRef } from "../classes/message/contentParts.js";
+import { Result } from "../types/result.js";
+/**
+ * Shared behaviour for the built-in file providers: the try/catch, secret
+ * redaction, logging, and Result wrapping are identical across providers, so
+ * they live here. Subclasses implement only the SDK-specific upload/delete and
+ * may throw freely — this class turns a thrown error into a redacted Failure.
+ */
+export declare abstract class BaseFileProvider implements FileProvider {
+    /** Human-readable provider label used in log and error messages, e.g. "OpenAI". */
+    protected abstract readonly label: string;
+    /** SDK-specific upload. May throw; the base class handles logging + redaction. */
+    protected abstract doUpload(data: Uint8Array, mimeType: string, ctx: FileProviderContext): Promise<ProviderFileRef>;
+    /** SDK-specific delete. May throw; the base class handles logging + redaction. */
+    protected abstract doDelete(ref: ProviderFileRef, ctx: {
+        apiKey: string;
+    }): Promise<void>;
+    upload(data: Uint8Array, mimeType: string, ctx: FileProviderContext): Promise<Result<ProviderFileRef>>;
+    delete(ref: ProviderFileRef, ctx: {
+        apiKey: string;
+    }): Promise<Result<void>>;
+    /**
+     * Redact the API key once, then reuse the scrubbed message for BOTH the log
+     * call and the returned Failure. The raw error object is never handed to the
+     * logger — SDKs sometimes attach the Authorization header to it. (B1)
+     */
+    private fail;
+}

package/dist/files/BaseFileProvider.js

@@ -0,0 +1,38 @@
+import { success, failure } from "../types/result.js";
+import { getLogger } from "../util/logger.js";
+import { redactSecret } from "../util/redact.js";
+/**
+ * Shared behaviour for the built-in file providers: the try/catch, secret
+ * redaction, logging, and Result wrapping are identical across providers, so
+ * they live here. Subclasses implement only the SDK-specific upload/delete and
+ * may throw freely — this class turns a thrown error into a redacted Failure.
+ */
+export class BaseFileProvider {
+    async upload(data, mimeType, ctx) {
+        try {
+            return success(await this.doUpload(data, mimeType, ctx));
+        }
+        catch (err) {
+            return this.fail("upload", err, ctx.apiKey);
+        }
+    }
+    async delete(ref, ctx) {
+        try {
+            await this.doDelete(ref, ctx);
+            return success(undefined);
+        }
+        catch (err) {
+            return this.fail("delete", err, ctx.apiKey);
+        }
+    }
+    /**
+     * Redact the API key once, then reuse the scrubbed message for BOTH the log
+     * call and the returned Failure. The raw error object is never handed to the
+     * logger — SDKs sometimes attach the Authorization header to it. (B1)
+     */
+    fail(op, err, apiKey) {
+        const message = redactSecret(err?.message ?? String(err), apiKey);
+        getLogger().error(`${this.label} file ${op} failed:`, message);
+        return failure(`${this.label} file ${op} failed: ${message}`);
+    }
+}

package/dist/files/anthropic.d.ts

@@ -0,0 +1,16 @@
+import type { FileProviderContext } from "../files.js";
+import type { ProviderFileRef } from "../classes/message/contentParts.js";
+import { BaseFileProvider } from "./BaseFileProvider.js";
+export declare function anthropicFileRef(uploaded: {
+    id: string;
+    mime_type?: string;
+}, mimeType: string): ProviderFileRef;
+declare class AnthropicFileProvider extends BaseFileProvider {
+    protected readonly label = "Anthropic";
+    protected doUpload(data: Uint8Array, mimeType: string, ctx: FileProviderContext): Promise<ProviderFileRef>;
+    protected doDelete(ref: ProviderFileRef, ctx: {
+        apiKey: string;
+    }): Promise<void>;
+}
+export declare const anthropicFileProvider: AnthropicFileProvider;
+export {};

package/dist/files/anthropic.js

@@ -0,0 +1,20 @@
+import Anthropic, { toFile } from "@anthropic-ai/sdk";
+import { BaseFileProvider } from "./BaseFileProvider.js";
+const FILES_BETA = "files-api-2025-04-14";
+export function anthropicFileRef(uploaded, mimeType) {
+    return { kind: "providerFile", provider: "anthropic", id: uploaded.id, mimeType: uploaded.mime_type ?? mimeType };
+}
+class AnthropicFileProvider extends BaseFileProvider {
+    label = "Anthropic";
+    async doUpload(data, mimeType, ctx) {
+        const client = new Anthropic({ apiKey: ctx.apiKey });
+        const file = await toFile(data, ctx.filename ?? "upload", { type: mimeType });
+        const uploaded = await client.beta.files.upload({ file, betas: [FILES_BETA] });
+        return anthropicFileRef(uploaded, mimeType);
+    }
+    async doDelete(ref, ctx) {
+        const client = new Anthropic({ apiKey: ctx.apiKey });
+        await client.beta.files.delete(ref.id, { betas: [FILES_BETA] });
+    }
+}
+export const anthropicFileProvider = new AnthropicFileProvider();

package/dist/files/google.d.ts

@@ -0,0 +1,18 @@
+import type { FileProviderContext } from "../files.js";
+import type { ProviderFileRef } from "../classes/message/contentParts.js";
+import { BaseFileProvider } from "./BaseFileProvider.js";
+export declare function googleFileRef(uploaded: {
+    name?: string;
+    uri?: string;
+    mimeType?: string;
+    expirationTime?: string;
+}, mimeType: string): ProviderFileRef;
+declare class GoogleFileProvider extends BaseFileProvider {
+    protected readonly label = "Google";
+    protected doUpload(data: Uint8Array, mimeType: string, ctx: FileProviderContext): Promise<ProviderFileRef>;
+    protected doDelete(ref: ProviderFileRef, ctx: {
+        apiKey: string;
+    }): Promise<void>;
+}
+export declare const googleFileProvider: GoogleFileProvider;
+export {};

package/dist/files/google.js

@@ -0,0 +1,38 @@
+import { GoogleGenAI } from "@google/genai";
+import { BaseFileProvider } from "./BaseFileProvider.js";
+export function googleFileRef(uploaded, mimeType) {
+    if (!uploaded.name) {
+        throw new Error("Google files.upload returned no name; cannot build a ProviderFileRef.");
+    }
+    let expiresAt;
+    if (uploaded.expirationTime) {
+        const parsed = Date.parse(uploaded.expirationTime);
+        if (Number.isFinite(parsed)) {
+            expiresAt = parsed;
+        }
+    }
+    return {
+        kind: "providerFile",
+        provider: "google",
+        id: uploaded.name,
+        uri: uploaded.uri,
+        mimeType: uploaded.mimeType ?? mimeType,
+        expiresAt,
+    };
+}
+class GoogleFileProvider extends BaseFileProvider {
+    label = "Google";
+    async doUpload(data, mimeType, ctx) {
+        const ai = new GoogleGenAI({ apiKey: ctx.apiKey });
+        // P2 (follow-up): `new Blob([data])` copies the buffer; prefer a no-copy /
+        // streaming form if the SDK supports it. Blob is acceptable for v1.
+        const blob = new Blob([data], { type: mimeType });
+        const uploaded = await ai.files.upload({ file: blob, config: { mimeType } });
+        return googleFileRef(uploaded, mimeType);
+    }
+    async doDelete(ref, ctx) {
+        const ai = new GoogleGenAI({ apiKey: ctx.apiKey });
+        await ai.files.delete({ name: ref.id });
+    }
+}
+export const googleFileProvider = new GoogleFileProvider();

package/dist/files/openai.d.ts

@@ -0,0 +1,16 @@
+import type { FileProviderContext } from "../files.js";
+import type { ProviderFileRef } from "../classes/message/contentParts.js";
+import { BaseFileProvider } from "./BaseFileProvider.js";
+/** Maps a created OpenAI file (extra response fields intentionally ignored) to a ref. */
+export declare function openaiFileRef(created: {
+    id: string;
+}, mimeType: string): ProviderFileRef;
+declare class OpenAIFileProvider extends BaseFileProvider {
+    protected readonly label = "OpenAI";
+    protected doUpload(data: Uint8Array, mimeType: string, ctx: FileProviderContext): Promise<ProviderFileRef>;
+    protected doDelete(ref: ProviderFileRef, ctx: {
+        apiKey: string;
+    }): Promise<void>;
+}
+export declare const openaiFileProvider: OpenAIFileProvider;
+export {};

package/dist/files/openai.js

@@ -0,0 +1,23 @@
+import OpenAI from "openai";
+import { toFile } from "openai/uploads";
+import { BaseFileProvider } from "./BaseFileProvider.js";
+/** Maps a created OpenAI file (extra response fields intentionally ignored) to a ref. */
+export function openaiFileRef(created, mimeType) {
+    return { kind: "providerFile", provider: "openai", id: created.id, mimeType };
+}
+class OpenAIFileProvider extends BaseFileProvider {
+    label = "OpenAI";
+    async doUpload(data, mimeType, ctx) {
+        const client = new OpenAI({ apiKey: ctx.apiKey });
+        const file = await toFile(data, ctx.filename ?? "upload", { type: mimeType });
+        // S5: the mapper below is trivial and won't throw post-create, so no orphan
+        // is left here; a provider whose mapper does real work should best-effort delete.
+        const created = await client.files.create({ file, purpose: "user_data" });
+        return openaiFileRef(created, mimeType);
+    }
+    async doDelete(ref, ctx) {
+        const client = new OpenAI({ apiKey: ctx.apiKey });
+        await client.files.delete(ref.id);
+    }
+}
+export const openaiFileProvider = new OpenAIFileProvider();

package/dist/files.d.ts

@@ -0,0 +1,46 @@
+import { Result } from "./types/result.js";
+import type { SmolConfig } from "./types.js";
+import { ProviderFileRef } from "./classes/message/contentParts.js";
+import { BlobRef } from "./util/imageRef.js";
+/** Default cap on a resolved upload's size. Callers can raise it via opts.maxBytes. */
+export declare const DEFAULT_UPLOAD_BYTES: number;
+/**
+ * Options for {@link uploadFile}.
+ *
+ * ⚠️ Security: `{ kind: "path" }` sources read any file the process can access —
+ * do NOT pass untrusted user input as a path. `{ kind: "url" }` sources fetch
+ * arbitrary http(s) URLs; in a server that accepts user URLs, treat this as an
+ * SSRF surface (a full private-IP guard is a planned follow-up).
+ *
+ * Lifecycle: uploaded files persist on the provider until you call `deleteFile`
+ * (OpenAI keeps them indefinitely — storage bills accrue; Anthropic applies a
+ * retention window, so a cached ref can 404 later; Google auto-expires ~48h,
+ * surfaced as `expiresAt`). `uploadFile` is the recommended path for files more
+ * than a few MB — it sends bytes directly, avoiding the base64 round-trip that
+ * inline attachments pay.
+ */
+export type UploadFileOptions = {
+    provider: string;
+    mimeType?: string;
+    filename?: string;
+    /** Max resolved size in bytes. Default {@link DEFAULT_UPLOAD_BYTES} (100 MB). */
+    maxBytes?: number;
+    apiKey?: SmolConfig["apiKey"];
+};
+export type FileProviderContext = {
+    apiKey: string;
+    filename?: string;
+};
+export type FileProvider = {
+    upload(data: Uint8Array, mimeType: string, ctx: FileProviderContext): Promise<Result<ProviderFileRef>>;
+    delete(ref: ProviderFileRef, ctx: {
+        apiKey: string;
+    }): Promise<Result<void>>;
+};
+export declare function registerFileProvider(name: string, impl: FileProvider): void;
+/** Test-only: clear all registered custom providers so registrations don't leak across tests. */
+export declare function _resetForTests(): void;
+export declare function uploadFile(source: BlobRef, opts: UploadFileOptions): Promise<Result<ProviderFileRef>>;
+export declare function deleteFile(ref: ProviderFileRef, opts?: {
+    apiKey?: SmolConfig["apiKey"];
+}): Promise<Result<void>>;

package/dist/files.js

@@ -0,0 +1,70 @@
+import { failure } from "./types/result.js";
+import { loadBlob } from "./util/imageRef.js";
+import { fileFamily } from "./util/attachments.js";
+import { resolveApiKey } from "./util/provider.js";
+import { openaiFileProvider } from "./files/openai.js";
+import { anthropicFileProvider } from "./files/anthropic.js";
+import { googleFileProvider } from "./files/google.js";
+/** Default cap on a resolved upload's size. Callers can raise it via opts.maxBytes. */
+export const DEFAULT_UPLOAD_BYTES = 100 * 1024 * 1024;
+const BUILT_INS = {
+    openai: openaiFileProvider,
+    anthropic: anthropicFileProvider,
+    google: googleFileProvider,
+};
+const registered = Object.create(null);
+export function registerFileProvider(name, impl) {
+    registered[name] = impl;
+}
+/** Test-only: clear all registered custom providers so registrations don't leak across tests. */
+export function _resetForTests() {
+    for (const name of Object.keys(registered)) {
+        delete registered[name];
+    }
+}
+// First-party built-ins win (not registry-overridable); unknown → registry.
+function selectProvider(provider) {
+    const family = fileFamily(provider);
+    if (family !== null) {
+        return { impl: BUILT_INS[family], builtin: true };
+    }
+    const custom = registered[provider];
+    if (custom) {
+        return { impl: custom, builtin: false };
+    }
+    return null;
+}
+export async function uploadFile(source, opts) {
+    const sel = selectProvider(opts.provider);
+    if (!sel) {
+        return failure(`Provider "${opts.provider}" has no Files API. Supported: openai, anthropic, google.`);
+    }
+    const maxBytes = opts.maxBytes ?? DEFAULT_UPLOAD_BYTES;
+    let loaded;
+    try {
+        loaded = await loadBlob(source, { maxBytes });
+    }
+    catch (err) {
+        return failure(`Failed to load file for upload: ${err.message}`);
+    }
+    const mimeType = opts.mimeType ?? loaded.mimeType;
+    if (!mimeType || mimeType.trim() === "") {
+        return failure("Could not determine the file's MIME type; pass opts.mimeType.");
+    }
+    const apiKey = resolveApiKey(opts.provider, { apiKey: opts.apiKey });
+    if (sel.builtin && !apiKey) {
+        return failure(`No API key for provider "${opts.provider}". Set config.apiKey or the provider's env var.`);
+    }
+    return sel.impl.upload(loaded.data, mimeType, { apiKey: apiKey ?? "", filename: opts.filename });
+}
+export async function deleteFile(ref, opts = {}) {
+    const sel = selectProvider(ref.provider);
+    if (!sel) {
+        return failure(`Provider "${ref.provider}" has no Files API.`);
+    }
+    const apiKey = resolveApiKey(ref.provider, { apiKey: opts.apiKey });
+    if (sel.builtin && !apiKey) {
+        return failure(`No API key for provider "${ref.provider}".`);
+    }
+    return sel.impl.delete(ref, { apiKey: apiKey ?? "" });
+}

package/dist/image/openaiCompat.d.ts

@@ -0,0 +1,9 @@
+import { ImageInput, ImageConfig, ImageGenResult } from "../image.js";
+import { Result } from "../types/result.js";
+/**
+ * Generic OpenAI-compatible image generation. Used by litellm/openai-compat —
+ * any backend that speaks the OpenAI `/images/generations` shape. Image edits
+ * are not supported here (the multipart upload shape varies between backends);
+ * pass a plain prompt only.
+ */
+export declare function openaiCompatImage(input: ImageInput, config: ImageConfig, apiKey: string, baseURL: string): Promise<Result<ImageGenResult>>;

package/dist/image/openaiCompat.js

@@ -0,0 +1,60 @@
+import OpenAI from "openai";
+import { success, failure } from "../types/result.js";
+import { omitUndefined } from "../util/util.js";
+/**
+ * Generic OpenAI-compatible image generation. Used by litellm/openai-compat —
+ * any backend that speaks the OpenAI `/images/generations` shape. Image edits
+ * are not supported here (the multipart upload shape varies between backends);
+ * pass a plain prompt only.
+ */
+export async function openaiCompatImage(input, config, apiKey, baseURL) {
+    try {
+        const normalized = typeof input === "string" ? { prompt: input } : input;
+        const hasImages = !!(normalized.images && normalized.images.length > 0);
+        if (hasImages) {
+            return failure("openai-compat: image edits (passing `images`) are not supported on this generic adapter. Use the `openai` provider for OpenAI image edits.");
+        }
+        if (normalized.mask) {
+            return failure("openai-compat: image masks are not supported on this generic adapter.");
+        }
+        const client = new OpenAI({ apiKey, baseURL });
+        const params = omitUndefined({
+            model: config.model,
+            prompt: normalized.prompt,
+            n: config.n,
+            size: config.size,
+            quality: config.quality,
+            output_format: config.outputFormat,
+            background: config.background,
+            ...(config.metadata ?? {}),
+        });
+        const response = await client.images.generate(params);
+        const mimeType = mimeFromFormat(config.outputFormat) ?? "image/png";
+        const images = (response.data ?? []).map((d) => ({
+            data: new Uint8Array(Buffer.from(d.b64_json, "base64")),
+            mimeType,
+            revisedPrompt: d.revised_prompt,
+        }));
+        return success({
+            images,
+            model: config.model,
+        });
+    }
+    catch (err) {
+        return failure(err instanceof Error
+            ? err.message
+            : "OpenAI-compatible image request failed");
+    }
+}
+function mimeFromFormat(format) {
+    switch (format) {
+        case "png":
+            return "image/png";
+        case "jpeg":
+            return "image/jpeg";
+        case "webp":
+            return "image/webp";
+        default:
+            return undefined;
+    }
+}

package/dist/image.d.ts

@@ -17,8 +17,19 @@ export type ImageConfig = {
     quality?: "low" | "medium" | "high" | "auto";
     outputFormat?: "png" | "jpeg" | "webp";
     background?: "transparent" | "opaque" | "auto";
-    openAiApiKey?: string;
-    googleApiKey?: string;
+    /** API keys, nested by provider. Falls back to env vars
+     *  (OPENAI_API_KEY / GEMINI_API_KEY / LITELLM_API_KEY / OPENAI_COMPAT_API_KEY). */
+    apiKey?: {
+        openAi?: string;
+        google?: string;
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
+    /** Custom base URLs, nested by provider. */
+    baseUrl?: {
+        liteLlm?: string;
+        openAiCompat?: string;
+    };
     metadata?: Record<string, unknown>;
     modelData?: ModelDataBlob;
 };