smoltalk 0.5.1 → 0.7.0

package/dist/classes/message/index.d.ts

@@ -8,7 +8,8 @@ import type { AssistantMessageJSON } from "./AssistantMessage.js";
 import type { DeveloperMessageJSON } from "./DeveloperMessage.js";
 import type { SystemMessageJSON } from "./SystemMessage.js";
 import type { ToolMessageJSON } from "./ToolMessage.js";
-import { CostEstimate, TextPart, TokenUsage } from "../../types.js";
+import { CostEstimate, TextPart, TokenUsage, UserContentInput, ImagePart, FilePart } from "../../types.js";
+import type { ImageRef } from "../../util/imageRef.js";
 export * from "./AssistantMessage.js";
 export * from "./BaseMessage.js";
 export * from "./DeveloperMessage.js";
@@ -16,10 +17,15 @@ export * from "./SystemMessage.js";
 export * from "./ToolMessage.js";
 export * from "./UserMessage.js";
 export declare function messageFromJSON(json: MessageJSON): Message;
-export declare function userMessage(content: string, options?: {
+export declare function userMessage(content: UserContentInput, options?: {
     name?: string;
     rawData?: any;
 }): UserMessage;
+export declare function textPart(text: string): TextPart;
+export declare function imagePart(source: ImageRef): ImagePart;
+export declare function filePart(source: ImageRef, options?: {
+    filename?: string;
+}): FilePart;
 export declare function assistantMessage(content: string | Array<TextPart> | null, options?: {
     name?: string;
     audio?: any | null;

package/dist/classes/message/index.js

@@ -28,6 +28,18 @@ export function messageFromJSON(json) {
 export function userMessage(content, options = {}) {
     return new UserMessage(content, options);
 }
+export function textPart(text) {
+    return { type: "text", text };
+}
+export function imagePart(source) {
+    return { type: "image", source };
+}
+export function filePart(source, options = {}) {
+    if (options.filename === undefined) {
+        return { type: "file", source };
+    }
+    return { type: "file", source, filename: options.filename };
+}
 export function assistantMessage(content, options = {}) {
     return new AssistantMessage(content, options);
 }

package/dist/classes/message/renderers/AnthropicRenderer.d.ts

@@ -0,0 +1,43 @@
+import type { PartRenderer } from "./PartRenderer.js";
+import type { TextPart, ImagePart, FilePart } from "../contentParts.js";
+/** Renders parts for the Anthropic Messages API. */
+export declare class AnthropicRenderer implements PartRenderer<any> {
+    text(part: TextPart): {
+        type: string;
+        text: string;
+    };
+    image(part: ImagePart): {
+        type: string;
+        source: {
+            type: string;
+            file_id: string;
+        };
+    } | {
+        type: string;
+        source: {
+            type: "url";
+            url: string;
+        } | {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    };
+    file(part: FilePart): {
+        type: string;
+        source: {
+            type: string;
+            file_id: string;
+        };
+    } | {
+        type: string;
+        source: {
+            type: "url";
+            url: string;
+        } | {
+            type: "base64";
+            media_type: string;
+            data: string;
+        };
+    };
+}

package/dist/classes/message/renderers/AnthropicRenderer.js

@@ -0,0 +1,19 @@
+import { anthropicSource } from "../../../util/attachments.js";
+/** Renders parts for the Anthropic Messages API. */
+export class AnthropicRenderer {
+    text(part) {
+        return { type: "text", text: part.text };
+    }
+    image(part) {
+        if (part.source.kind === "providerFile") {
+            return { type: "image", source: { type: "file", file_id: part.source.id } };
+        }
+        return { type: "image", source: anthropicSource(part.source) };
+    }
+    file(part) {
+        if (part.source.kind === "providerFile") {
+            return { type: "document", source: { type: "file", file_id: part.source.id } };
+        }
+        return { type: "document", source: anthropicSource(part.source) };
+    }
+}

package/dist/classes/message/renderers/GoogleRenderer.d.ts

@@ -0,0 +1,35 @@
+import type { PartRenderer } from "./PartRenderer.js";
+import type { TextPart, ImagePart, FilePart } from "../contentParts.js";
+/** Renders parts for the Google Gemini API. */
+export declare class GoogleRenderer implements PartRenderer<any> {
+    text(part: TextPart): {
+        text: string;
+    };
+    image(part: ImagePart): {
+        fileData: {
+            fileUri: string;
+            mimeType: string;
+        };
+        inlineData?: undefined;
+    } | {
+        inlineData: {
+            mimeType: string;
+            data: string;
+        };
+        fileData?: undefined;
+    };
+    file(part: FilePart): {
+        fileData: {
+            fileUri: string;
+            mimeType: string;
+        };
+        inlineData?: undefined;
+    } | {
+        inlineData: {
+            mimeType: string;
+            data: string;
+        };
+        fileData?: undefined;
+    };
+    private sourcePart;
+}

package/dist/classes/message/renderers/GoogleRenderer.js

@@ -0,0 +1,26 @@
+import { refToBase64 } from "../../../util/attachments.js";
+/** Renders parts for the Google Gemini API. */
+export class GoogleRenderer {
+    text(part) {
+        return { text: part.text };
+    }
+    image(part) {
+        return this.sourcePart(part.source);
+    }
+    file(part) {
+        return this.sourcePart(part.source);
+    }
+    sourcePart(source) {
+        if (source.kind === "providerFile") {
+            // `fileData` needs both a uri and a mimeType; a ref missing either (e.g. a
+            // hand-deserialized one) would otherwise emit `{ fileUri: undefined }` and
+            // fail with a confusing provider error, so reject it clearly here.
+            if (!source.uri || !source.mimeType) {
+                throw new Error("Google file reference is missing uri/mimeType; re-upload it via uploadFile({ provider: \"google\" }).");
+            }
+            return { fileData: { fileUri: source.uri, mimeType: source.mimeType } };
+        }
+        const { base64, mimeType } = refToBase64(source);
+        return { inlineData: { mimeType, data: base64 } };
+    }
+}

package/dist/classes/message/renderers/JSONRenderer.d.ts

@@ -0,0 +1,8 @@
+import type { PartRenderer } from "./PartRenderer.js";
+import type { TextPart, ImagePart, FilePart, UserContentPart } from "../contentParts.js";
+/** Renders parts back to a JSON-safe UserContentPart (for toJSON serialization). */
+export declare class JSONRenderer implements PartRenderer<UserContentPart> {
+    text(part: TextPart): UserContentPart;
+    image(part: ImagePart): UserContentPart;
+    file(part: FilePart): UserContentPart;
+}

package/dist/classes/message/renderers/JSONRenderer.js

@@ -0,0 +1,21 @@
+import { refToBase64 } from "../../../util/attachments.js";
+/** In-memory `bytes` don't survive JSON, so materialize them as base64; other sources pass through. */
+function bytesToBase64(source) {
+    if (source.kind === "bytes") {
+        const { base64, mimeType } = refToBase64(source);
+        return { kind: "base64", base64, mimeType };
+    }
+    return source;
+}
+/** Renders parts back to a JSON-safe UserContentPart (for toJSON serialization). */
+export class JSONRenderer {
+    text(part) {
+        return part;
+    }
+    image(part) {
+        return { type: "image", source: bytesToBase64(part.source) };
+    }
+    file(part) {
+        return { type: "file", source: bytesToBase64(part.source), filename: part.filename };
+    }
+}

package/dist/classes/message/renderers/OpenAIChatRenderer.d.ts

@@ -0,0 +1,30 @@
+import type { PartRenderer } from "./PartRenderer.js";
+import type { TextPart, ImagePart, FilePart } from "../contentParts.js";
+/** Renders parts for the OpenAI Chat Completions API. */
+export declare class OpenAIChatRenderer implements PartRenderer<any> {
+    text(part: TextPart): {
+        type: string;
+        text: string;
+    };
+    image(part: ImagePart): {
+        type: string;
+        image_url: {
+            url: string;
+        };
+    };
+    file(part: FilePart): {
+        type: string;
+        file: {
+            file_id: string;
+            file_data?: undefined;
+            filename?: undefined;
+        };
+    } | {
+        type: string;
+        file: {
+            file_data: string;
+            filename: string;
+            file_id?: undefined;
+        };
+    };
+}

package/dist/classes/message/renderers/OpenAIChatRenderer.js

@@ -0,0 +1,20 @@
+import { refToBase64, toDataUri, openAiImageUrl, attachmentFilename } from "../../../util/attachments.js";
+/** Renders parts for the OpenAI Chat Completions API. */
+export class OpenAIChatRenderer {
+    text(part) {
+        return { type: "text", text: part.text };
+    }
+    image(part) {
+        if (part.source.kind === "providerFile") {
+            throw new Error("OpenAI Chat Completions cannot reference an image by file id; use the openai-responses provider or inline the image.");
+        }
+        return { type: "image_url", image_url: { url: openAiImageUrl(part.source) } };
+    }
+    file(part) {
+        if (part.source.kind === "providerFile") {
+            return { type: "file", file: { file_id: part.source.id } };
+        }
+        const { base64, mimeType } = refToBase64(part.source);
+        return { type: "file", file: { file_data: toDataUri(base64, mimeType), filename: attachmentFilename(part.filename) } };
+    }
+}

package/dist/classes/message/renderers/OpenAIResponsesRenderer.d.ts

@@ -0,0 +1,39 @@
+import type { PartRenderer } from "./PartRenderer.js";
+import type { TextPart, ImagePart, FilePart } from "../contentParts.js";
+/** Renders parts for the OpenAI Responses API. */
+export declare class OpenAIResponsesRenderer implements PartRenderer<any> {
+    text(part: TextPart): {
+        type: string;
+        text: string;
+    };
+    image(part: ImagePart): {
+        type: string;
+        file_id: string;
+        image_url?: undefined;
+        detail?: undefined;
+    } | {
+        type: string;
+        image_url: string;
+        detail: string;
+        file_id?: undefined;
+    };
+    file(part: FilePart): {
+        type: string;
+        file_id: string;
+        file_url?: undefined;
+        file_data?: undefined;
+        filename?: undefined;
+    } | {
+        type: string;
+        file_url: string;
+        file_id?: undefined;
+        file_data?: undefined;
+        filename?: undefined;
+    } | {
+        type: string;
+        file_data: string;
+        filename: string;
+        file_id?: undefined;
+        file_url?: undefined;
+    };
+}

package/dist/classes/message/renderers/OpenAIResponsesRenderer.js

@@ -0,0 +1,23 @@
+import { refToBase64, toDataUri, openAiImageUrl, attachmentFilename } from "../../../util/attachments.js";
+/** Renders parts for the OpenAI Responses API. */
+export class OpenAIResponsesRenderer {
+    text(part) {
+        return { type: "input_text", text: part.text };
+    }
+    image(part) {
+        if (part.source.kind === "providerFile") {
+            return { type: "input_image", file_id: part.source.id };
+        }
+        return { type: "input_image", image_url: openAiImageUrl(part.source), detail: "auto" };
+    }
+    file(part) {
+        if (part.source.kind === "providerFile") {
+            return { type: "input_file", file_id: part.source.id };
+        }
+        if (part.source.kind === "url") {
+            return { type: "input_file", file_url: part.source.url };
+        }
+        const { base64, mimeType } = refToBase64(part.source);
+        return { type: "input_file", file_data: toDataUri(base64, mimeType), filename: attachmentFilename(part.filename) };
+    }
+}

package/dist/classes/message/renderers/PartRenderer.d.ts

@@ -0,0 +1,14 @@
+import type { TextPart, ImagePart, FilePart, UserContentPart } from "../contentParts.js";
+/**
+ * A per-provider renderer for user-content parts. Each provider implements one
+ * of these (one class per file, in this directory) so the message class stays
+ * thin: the serializer picks a renderer and walks the parts with {@link renderParts}.
+ * `text`/`image`/`file` return that provider's native representation of a part.
+ */
+export interface PartRenderer<T> {
+    text(part: TextPart): T;
+    image(part: ImagePart): T;
+    file(part: FilePart): T;
+}
+/** Walk content parts, dispatching each to the renderer's matching method. */
+export declare function renderParts<T>(parts: UserContentPart[], renderer: PartRenderer<T>): T[];

package/dist/classes/message/renderers/PartRenderer.js

@@ -0,0 +1,16 @@
+/** Walk content parts, dispatching each to the renderer's matching method. */
+export function renderParts(parts, renderer) {
+    const out = [];
+    for (const part of parts) {
+        if (part.type === "text") {
+            out.push(renderer.text(part));
+        }
+        else if (part.type === "image") {
+            out.push(renderer.image(part));
+        }
+        else {
+            out.push(renderer.file(part));
+        }
+    }
+    return out;
+}

package/dist/client.d.ts

@@ -4,6 +4,10 @@ export * from "./clients/openai.js";
 export * from "./clients/openaiResponses.js";
 export * from "./clients/baseClient.js";
 export * from "./clients/ollama.js";
+export * from "./clients/openaiCompat.js";
+export * from "./clients/openrouter.js";
+export * from "./clients/deepinfra.js";
+export * from "./clients/litellm.js";
 import { BaseClient } from "./clients/baseClient.js";
 import { SmolClientConfig } from "./types.js";
 export declare function registerProvider(providerName: string, clientClass: typeof BaseClient): void;

package/dist/client.js

@@ -4,11 +4,19 @@ export * from "./clients/openai.js";
 export * from "./clients/openaiResponses.js";
 export * from "./clients/baseClient.js";
 export * from "./clients/ollama.js";
+export * from "./clients/openaiCompat.js";
+export * from "./clients/openrouter.js";
+export * from "./clients/deepinfra.js";
+export * from "./clients/litellm.js";
 import { SmolAnthropic } from "./clients/anthropic.js";
 import { SmolGoogle } from "./clients/google.js";
 import { SmolOllama } from "./clients/ollama.js";
 import { SmolOpenAi } from "./clients/openai.js";
 import { SmolOpenAiResponses } from "./clients/openaiResponses.js";
+import { SmolOpenAiCompat } from "./clients/openaiCompat.js";
+import { SmolOpenRouter } from "./clients/openrouter.js";
+import { SmolDeepInfra } from "./clients/deepinfra.js";
+import { SmolLiteLlm } from "./clients/litellm.js";
 import { getModel, isTextModel } from "./models.js";
 import { SmolError } from "./smolError.js";
 import { resolveApiKey, resolveProvider } from "./util/provider.js";
@@ -36,43 +44,56 @@ export function getClient(config) {
             throw new SmolError(`Only text models are supported currently. ${modelName} is a ${model?.type} model.`);
         }
     }
+    // Resolve API keys from config or env vars and inject them back into the
+    // nested apiKey map. The client constructors also read env vars directly,
+    // but this lets getClient surface a clear error before construction.
     const resolvedKeys = {
-        openAiApiKey: resolveApiKey("openai", config),
-        googleApiKey: resolveApiKey("google", config),
-        anthropicApiKey: resolveApiKey("anthropic", config),
+        openAi: resolveApiKey("openai", config),
+        google: resolveApiKey("google", config),
+        anthropic: resolveApiKey("anthropic", config),
+        ollama: resolveApiKey("ollama", config),
+        openRouter: resolveApiKey("openrouter", config),
+        deepInfra: resolveApiKey("deepinfra", config),
+        liteLlm: resolveApiKey("litellm", config),
+        openAiCompat: resolveApiKey("openai-compat", config),
     };
     const clientConfig = {
         messages: [],
         ...config,
-        ...resolvedKeys,
+        apiKey: { ...resolvedKeys, ...config.apiKey },
         model: modelName,
     };
     switch (provider) {
         case "anthropic":
-            if (!resolvedKeys.anthropicApiKey) {
-                throw new SmolError("No Anthropic API key provided. Please provide an Anthropic API key in the config using anthropicApiKey, or set the ANTHROPIC_API_KEY environment variable.");
+            if (!resolvedKeys.anthropic) {
+                throw new SmolError("No Anthropic API key provided. Please provide an Anthropic API key in the config using apiKey.anthropic, or set the ANTHROPIC_API_KEY environment variable.");
             }
-            return new SmolAnthropic({
-                ...clientConfig,
-                anthropicApiKey: resolvedKeys.anthropicApiKey,
-            });
+            return new SmolAnthropic(clientConfig);
         case "openai":
-            if (!resolvedKeys.openAiApiKey) {
-                throw new SmolError("No OpenAI API key provided. Please provide an OpenAI API key in the config using openAiApiKey, or set the OPENAI_API_KEY environment variable.");
+            if (!resolvedKeys.openAi) {
+                throw new SmolError("No OpenAI API key provided. Please provide an OpenAI API key in the config using apiKey.openAi, or set the OPENAI_API_KEY environment variable.");
             }
             return new SmolOpenAi(clientConfig);
         case "openai-responses":
-            if (!resolvedKeys.openAiApiKey) {
-                throw new SmolError("No OpenAI API key provided. Please provide an OpenAI API key in the config using openAiApiKey, or set the OPENAI_API_KEY environment variable.");
+            if (!resolvedKeys.openAi) {
+                throw new SmolError("No OpenAI API key provided. Please provide an OpenAI API key in the config using apiKey.openAi, or set the OPENAI_API_KEY environment variable.");
             }
             return new SmolOpenAiResponses(clientConfig);
         case "google":
-            if (!resolvedKeys.googleApiKey) {
-                throw new SmolError("No Google API key provided. Please provide a Google API key in the config using googleApiKey, or set the GEMINI_API_KEY environment variable.");
+            if (!resolvedKeys.google) {
+                throw new SmolError("No Google API key provided. Please provide a Google API key in the config using apiKey.google, or set the GEMINI_API_KEY environment variable.");
             }
             return new SmolGoogle(clientConfig);
         case "ollama":
             return new SmolOllama(clientConfig);
+        case "openrouter":
+            return new SmolOpenRouter(clientConfig);
+        case "deepinfra":
+            return new SmolDeepInfra(clientConfig);
+        case "litellm":
+            return new SmolLiteLlm(clientConfig);
+        case "openai-compat":
+            return new SmolOpenAiCompat(clientConfig);
         default:
             if (provider in registeredProviders) {
                 const ClientClass = registeredProviders[provider];

package/dist/clients/anthropic.d.ts

@@ -1,11 +1,32 @@
+import type { MessageParam, Tool } from "@anthropic-ai/sdk/resources/messages.js";
 import { PromptResult, Result, SmolClient, SmolConfig, StreamChunk, HostedToolResult } from "../types.js";
 import { BaseClient } from "./baseClient.js";
 import { ModelName } from "../models.js";
 export declare function anthropicWebSearchEntries(hostedTools?: string[]): any[];
 export declare function parseAnthropicHostedTools(response: any, provider: string): HostedToolResult[];
-export type SmolAnthropicConfig = SmolConfig & {
-    anthropicApiKey: string;
+type EphemeralCacheControl = {
+    type: "ephemeral";
 };
+type SystemBlock = {
+    type: "text";
+    text: string;
+    cache_control?: EphemeralCacheControl;
+};
+type AnthropicRequestShape = {
+    system: string | SystemBlock[] | undefined;
+    messages: MessageParam[];
+    tools: Tool[] | undefined;
+};
+/**
+ * Attach ephemeral cache_control breakpoints to (up to) three places:
+ *   1. the last tool definition
+ *   2. the last system block (promoting system from string to array form)
+ *   3. the last block of the last user message
+ *
+ * Anthropic enforces minimum prefix sizes; smaller prefixes silently no-op.
+ */
+export declare function applyCacheBreakpoints(req: AnthropicRequestShape): AnthropicRequestShape;
+export type SmolAnthropicConfig = SmolConfig;
 export declare class SmolAnthropic extends BaseClient implements SmolClient {
     private client;
     private logger;
@@ -25,3 +46,4 @@ export declare class SmolAnthropic extends BaseClient implements SmolClient {
     _textSync(config: SmolConfig): Promise<Result<PromptResult>>;
     _textStream(config: SmolConfig): AsyncGenerator<StreamChunk>;
 }
+export {};

package/dist/clients/anthropic.js

@@ -2,6 +2,7 @@ import Anthropic from "@anthropic-ai/sdk";
 import { ToolCall } from "../classes/ToolCall.js";
 import { SystemMessage, DeveloperMessage } from "../classes/message/index.js";
 import { getLogger } from "../util/logger.js";
+import { redactAttachments } from "../util/redact.js";
 import { success, } from "../types.js";
 import { WEB_SEARCH, webSearchResult, applyHostedToolCost } from "../util/hostedTools.js";
 import { zodToAnthropicTool } from "../util/tool.js";
@@ -75,7 +76,7 @@ function thinkingStyleFor(modelName, modelData) {
  *
  * Anthropic enforces minimum prefix sizes; smaller prefixes silently no-op.
  */
-function applyCacheBreakpoints(req) {
+export function applyCacheBreakpoints(req) {
     const cc = { type: "ephemeral" };
     // Tools: mark the last tool.
     let tools = req.tools;
@@ -149,7 +150,11 @@ export class SmolAnthropic extends BaseClient {
     model;
     constructor(config) {
         super(config);
-        this.client = new Anthropic({ apiKey: config.anthropicApiKey });
+        const apiKey = config.apiKey?.anthropic || process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            throw new Error("Anthropic API key is required for SmolAnthropic client.");
+        }
+        this.client = new Anthropic({ apiKey });
         this.logger = getLogger();
         this.model = new Model(config.model, undefined, config.modelData);
     }
@@ -289,7 +294,7 @@ export class SmolAnthropic extends BaseClient {
             thinking,
             output_config: outputConfig,
         };
-        this.logger.debug("Sending request to Anthropic:", debugData);
+        this.logger.debug("Sending request to Anthropic:", redactAttachments(debugData));
         this.statelogClient?.promptRequest(debugData);
         const signal = this.getAbortSignal(config);
         let response;
@@ -358,7 +363,7 @@ export class SmolAnthropic extends BaseClient {
             thinking,
             output_config: outputConfig,
         };
-        this.logger.debug("Sending streaming request to Anthropic:", streamDebugData);
+        this.logger.debug("Sending streaming request to Anthropic:", redactAttachments(streamDebugData));
         this.statelogClient?.promptRequest(streamDebugData);
         const signal = this.getAbortSignal(config);
         let stream;

package/dist/clients/baseClient.d.ts

@@ -13,6 +13,13 @@ export declare class BaseClient implements SmolClient {
         stream?: false;
     }): Promise<Result<PromptResult>>;
     checkMessageLimit(promptConfig: SmolConfig): Result<PromptResult> | null;
+    /**
+     * Gate on input modalities and resolve any image/PDF attachment refs
+     * (path/url/bytes → base64) before the synchronous serializers run. Returns
+     * the (possibly rewritten) config on success, or a Failure to surface. Shared
+     * by textSync and textStream so the two paths can't diverge.
+     */
+    protected prepareAttachments(config: SmolConfig): Promise<Result<SmolConfig>>;
     textSync(promptConfig: SmolConfig): Promise<Result<PromptResult>>;
     checkForToolLoops(promptConfig: SmolConfig): {
         continue: boolean;

package/dist/clients/baseClient.js

@@ -5,6 +5,9 @@ import { getStatelogClient } from "../statelogClient.js";
 import { stripCodeFence } from "../util/util.js";
 import { success, failure, } from "../types.js";
 import { validateHostedTools } from "../util/hostedTools.js";
+import { resolveMessageAttachments, messagesHaveAttachments, DEFAULT_MAX_ATTACHMENT_BYTES } from "./resolveAttachments.js";
+import { validateModalities } from "../util/modalities.js";
+import { resolveProvider } from "../util/provider.js";
 import { z } from "zod";
 const DEFAULT_NUM_RETRIES = 2;
 export class BaseClient {
@@ -52,10 +55,40 @@ export class BaseClient {
         }
         return null;
     }
+    /**
+     * Gate on input modalities and resolve any image/PDF attachment refs
+     * (path/url/bytes → base64) before the synchronous serializers run. Returns
+     * the (possibly rewritten) config on success, or a Failure to surface. Shared
+     * by textSync and textStream so the two paths can't diverge.
+     */
+    async prepareAttachments(config) {
+        const modalityResult = validateModalities(config);
+        if (modalityResult && modalityResult.success === false) {
+            return modalityResult;
+        }
+        if (!messagesHaveAttachments(config.messages)) {
+            return success(config);
+        }
+        const provider = resolveProvider(config.model, config.provider, config.modelData);
+        const maxBytes = config.attachments?.maxBytes ?? DEFAULT_MAX_ATTACHMENT_BYTES;
+        const resolved = await resolveMessageAttachments(config.messages, {
+            provider,
+            maxBytes,
+        });
+        if (!resolved.success) {
+            return resolved;
+        }
+        return success({ ...config, messages: resolved.value });
+    }
     async textSync(promptConfig) {
         const messageLimitResult = this.checkMessageLimit(promptConfig);
         if (messageLimitResult)
             return messageLimitResult;
+        const prepared = await this.prepareAttachments(promptConfig);
+        if (!prepared.success) {
+            return prepared;
+        }
+        promptConfig = prepared.value;
         const hostedError = validateHostedTools(promptConfig.hostedTools, promptConfig.model, promptConfig.provider, promptConfig.modelData);
         if (hostedError) {
             return failure(hostedError);
@@ -269,6 +302,12 @@ export class BaseClient {
             };
             return;
         }
+        const prepared = await this.prepareAttachments(config);
+        if (!prepared.success) {
+            yield { type: "error", error: prepared.error };
+            return;
+        }
+        config = prepared.value;
         const hostedError = validateHostedTools(config.hostedTools, config.model, config.provider, config.modelData);
         if (hostedError) {
             yield { type: "error", error: hostedError };

package/dist/clients/deepinfra.d.ts

@@ -0,0 +1,17 @@
+import { SmolOpenAiCompat } from "./openaiCompat.js";
+import type { SmolConfig } from "../types.js";
+/**
+ * DeepInfra client (https://deepinfra.com). OpenAI-compatible chat completions
+ * at the `/v1/openai` base URL.
+ *
+ * - Baked base URL `https://api.deepinfra.com/v1/openai` (override via config.baseUrl.deepInfra).
+ * - Key: config.apiKey.deepInfra or env DEEPINFRA_API_KEY.
+ * - Cost: reads `usage.estimated_cost` (USD).
+ */
+export declare class SmolDeepInfra extends SmolOpenAiCompat {
+    protected resolveClientOptions(config: SmolConfig): {
+        apiKey: string;
+        baseURL: string;
+    };
+    protected resolveCostUsd(usage: any): number | undefined;
+}