smoltalk 0.6.0 → 0.7.0

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/clients/anthropic.d.ts

@@ -1,8 +1,31 @@
+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[];
+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;
@@ -23,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;
@@ -293,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;
@@ -362,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/google.js

@@ -1,6 +1,7 @@
 import { GoogleGenAI } from "@google/genai";
 import { ToolCall } from "../classes/ToolCall.js";
 import { getLogger } from "../util/logger.js";
+import { redactAttachments } from "../util/redact.js";
 import { addCosts, addTokenUsage, success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
 import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
@@ -248,7 +249,7 @@ export class SmolGoogle extends BaseClient {
         });
     }
     async __textSync(request) {
-        this.logger.debug("Sending request to Google Gemini:", JSON.stringify(request, null, 2));
+        this.logger.debug("Sending request to Google Gemini:", JSON.stringify(redactAttachments(request), null, 2));
         this.statelogClient?.promptRequest(request);
         let result;
         try {
@@ -326,7 +327,7 @@ export class SmolGoogle extends BaseClient {
             request.config.responseMimeType = undefined;
             request.config.responseJsonSchema = undefined;
         }
-        this.logger.debug("Sending streaming request to Google Gemini:", JSON.stringify(request, null, 2));
+        this.logger.debug("Sending streaming request to Google Gemini:", JSON.stringify(redactAttachments(request), null, 2));
         this.statelogClient?.promptRequest(request);
         let stream;
         try {

package/dist/clients/ollama.js

@@ -1,6 +1,7 @@
 import { Ollama } from "ollama";
 import { ToolCall } from "../classes/ToolCall.js";
 import { getLogger } from "../util/logger.js";
+import { redactAttachments } from "../util/redact.js";
 import { success, } from "../types.js";
 import { zodToGoogleTool } from "../util/tool.js";
 import { sanitizeAttributes } from "../util/util.js";
@@ -66,14 +67,14 @@ export class SmolOllama extends BaseClient {
         throw error;
     }
     async _textSync(config) {
-        const messages = config.messages.map((msg) => msg.toOpenAIMessage());
+        const messages = config.messages.map((msg) => msg.toOllamaMessage());
         const tools = (config.tools || []).map((tool) => {
             return zodToGoogleTool(tool.name, tool.schema, {
                 description: tool.description,
             });
         });
         const request = {
-            messages: messages,
+            messages,
             model: this.getModel(),
         };
         if (tools.length > 0) {
@@ -83,7 +84,7 @@ export class SmolOllama extends BaseClient {
             request.format = config.responseFormat.toJSONSchema();
         }
         Object.assign(request, sanitizeAttributes(config.rawAttributes));
-        this.logger.debug("Sending request to Ollama:", JSON.stringify(request, null, 2));
+        this.logger.debug("Sending request to Ollama:", JSON.stringify(redactAttachments(request), null, 2));
         this.statelogClient?.promptRequest(request);
         const signal = this.getAbortSignal(config);
         const abortHandler = signal ? () => this.client.abort() : undefined;
@@ -119,14 +120,14 @@ export class SmolOllama extends BaseClient {
         return success({ output, toolCalls, usage, cost, model: this.getModel() });
     }
     async *_textStream(config) {
-        const messages = config.messages.map((msg) => msg.toOpenAIMessage());
+        const messages = config.messages.map((msg) => msg.toOllamaMessage());
         const tools = (config.tools || []).map((tool) => {
             return zodToGoogleTool(tool.name, tool.schema, {
                 description: tool.description,
             });
         });
         const request = {
-            messages: messages,
+            messages,
             model: this.getModel(),
             stream: true,
         };
@@ -137,7 +138,7 @@ export class SmolOllama extends BaseClient {
             request.format = config.responseFormat.toJSONSchema();
         }
         Object.assign(request, sanitizeAttributes(config.rawAttributes));
-        this.logger.debug("Sending streaming request to Ollama:", JSON.stringify(request, null, 2));
+        this.logger.debug("Sending streaming request to Ollama:", JSON.stringify(redactAttachments(request), null, 2));
         this.statelogClient?.promptRequest(request);
         const signal = this.getAbortSignal(config);
         const abortHandler = signal ? () => this.client.abort() : undefined;

package/dist/clients/openai.js

@@ -3,6 +3,7 @@ import { success, } from "../types.js";
 import { ToolCall } from "../classes/ToolCall.js";
 import { isFunctionToolCall, sanitizeAttributes } from "../util/util.js";
 import { getLogger } from "../util/logger.js";
+import { redactAttachments } from "../util/redact.js";
 import { BaseClient } from "./baseClient.js";
 import { SmolContentPolicyError, SmolContextWindowExceededError, smolErrorForStatus, } from "../smolError.js";
 import { extractHttpErrorFields } from "../util/httpError.js";
@@ -140,7 +141,7 @@ export class SmolOpenAi extends BaseClient {
     }
     async _textSync(config) {
         const request = this.buildRequest(config);
-        this.logger.debug("Sending request to OpenAI:", JSON.stringify(request, null, 2));
+        this.logger.debug("Sending request to OpenAI:", JSON.stringify(redactAttachments(request), null, 2));
         this.statelogClient?.promptRequest(request);
         const signal = this.getAbortSignal(config);
         let completion;
@@ -195,7 +196,7 @@ export class SmolOpenAi extends BaseClient {
     }
     async *_textStream(config) {
         const request = this.buildRequest(config);
-        this.logger.debug("Sending streaming request to OpenAI:", JSON.stringify(request, null, 2));
+        this.logger.debug("Sending streaming request to OpenAI:", JSON.stringify(redactAttachments(request), null, 2));
         this.statelogClient?.promptRequest(request);
         const signal = this.getAbortSignal(config);
         let completion;

package/dist/clients/openaiResponses.js

@@ -2,6 +2,7 @@ import OpenAI from "openai";
 import { success, } from "../types.js";
 import { ToolCall } from "../classes/ToolCall.js";
 import { getLogger } from "../util/logger.js";
+import { redactAttachments } from "../util/redact.js";
 import { BaseClient } from "./baseClient.js";
 import { zodToOpenAIResponsesTool } from "../util/tool.js";
 import { sanitizeAttributes } from "../util/util.js";
@@ -166,7 +167,7 @@ export class SmolOpenAiResponses extends BaseClient {
     }
     async _textSync(config) {
         const request = this.buildRequest(config);
-        this.logger.debug("Sending request to OpenAI Responses API:", JSON.stringify(request, null, 2));
+        this.logger.debug("Sending request to OpenAI Responses API:", JSON.stringify(redactAttachments(request), null, 2));
         this.statelogClient?.promptRequest(request);
         const signal = this.getAbortSignal(config);
         let response;
@@ -205,7 +206,7 @@ export class SmolOpenAiResponses extends BaseClient {
     }
     async *_textStream(config) {
         const request = this.buildRequest(config);
-        this.logger.debug("Sending streaming request to OpenAI Responses API:", JSON.stringify(request, null, 2));
+        this.logger.debug("Sending streaming request to OpenAI Responses API:", JSON.stringify(redactAttachments(request), null, 2));
         this.statelogClient?.promptRequest(request);
         const signal = this.getAbortSignal(config);
         let stream;

package/dist/clients/resolveAttachments.d.ts

@@ -0,0 +1,11 @@
+import { Message } from "../classes/message/index.js";
+import { Result } from "../types.js";
+export declare const DEFAULT_MAX_ATTACHMENT_BYTES: number;
+/** Whether any user message carries an image/file attachment part. */
+export declare function messagesHaveAttachments(messages: Message[]): boolean;
+/** Whether `provider` accepts a remote URL directly for this part type. */
+export declare function acceptsRemoteUrl(provider: string, partType: "image" | "file"): boolean;
+export declare function resolveMessageAttachments(messages: Message[], options: {
+    provider: string;
+    maxBytes: number;
+}): Promise<Result<Message[]>>;

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);
+}