@wingman-ai/gateway 0.4.2 → 0.4.4

package/dist/agent/config/xaiImageModel.js

@@ -0,0 +1,202 @@
+import { BaseChatModel } from "@langchain/core/language_models/chat_models";
+import { AIMessage, AIMessageChunk } from "@langchain/core/messages";
+import { ChatGenerationChunk } from "@langchain/core/outputs";
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const DEFAULT_XAI_BASE_URL = "https://api.x.ai/v1";
+const IMAGE_MODEL_NAME_PATTERN = /^grok-imagine-image(?:[-:._].*)?$/i;
+const XAI_IMAGE_PROMPT_MAX_CHARS = 7900;
+function isNativeXAIImageModel(modelName) {
+    return IMAGE_MODEL_NAME_PATTERN.test(modelName.trim());
+}
+function normalizeContentText(content) {
+    if ("string" == typeof content) return content.trim();
+    if (!Array.isArray(content)) return "";
+    const parts = content.map((part)=>{
+        if (!part || "object" != typeof part || Array.isArray(part)) return "";
+        const record = part;
+        return "text" === record.type && "string" == typeof record.text ? record.text.trim() : "";
+    }).filter(Boolean);
+    return parts.join("\n").trim();
+}
+function normalizeRole(message) {
+    const type = "string" == typeof message.type ? message.type : "function" == typeof message._getType ? String(message._getType() ?? "").toLowerCase() : "";
+    return type.toLowerCase();
+}
+function resolveAdditionalKwargs(message) {
+    const direct = message.additional_kwargs;
+    if (direct && "object" == typeof direct && !Array.isArray(direct)) return direct;
+    const kwargs = message.kwargs;
+    if (kwargs && "object" == typeof kwargs && !Array.isArray(kwargs)) {
+        const nested = kwargs.additional_kwargs;
+        if (nested && "object" == typeof nested && !Array.isArray(nested)) return nested;
+    }
+}
+function isHiddenMiddlewarePrompt(message, text) {
+    const additionalKwargs = resolveAdditionalKwargs(message);
+    const uiHidden = additionalKwargs?.ui_hidden === true || additionalKwargs?.uiHidden === true;
+    if (uiHidden) return true;
+    const source = "string" == typeof additionalKwargs?.source ? additionalKwargs.source.toLowerCase() : "";
+    if ("additional-message-middleware" === source) return true;
+    const normalized = text.toLowerCase();
+    return normalized.includes("# confidentiality (internal)") && normalized.includes("current date time (utc)");
+}
+function clampPromptLength(prompt) {
+    if (prompt.length <= XAI_IMAGE_PROMPT_MAX_CHARS) return prompt;
+    return prompt.slice(0, XAI_IMAGE_PROMPT_MAX_CHARS);
+}
+function buildPrompt(messages) {
+    const systemParts = [];
+    const visibleUserParts = [];
+    const fallbackUserParts = [];
+    for (const message of messages){
+        const text = normalizeContentText(message.content);
+        if (!text) continue;
+        const role = normalizeRole(message);
+        if ("system" === role) {
+            systemParts.push(text);
+            continue;
+        }
+        if ("human" === role || "user" === role) {
+            fallbackUserParts.push(text);
+            if (!isHiddenMiddlewarePrompt(message, text)) visibleUserParts.push(text);
+        }
+    }
+    const latestUserPrompt = visibleUserParts[visibleUserParts.length - 1] || fallbackUserParts[fallbackUserParts.length - 1];
+    if (!latestUserPrompt) throw new Error("xAI image generation requires a user prompt.");
+    const systemPrefix = systemParts.join("\n\n").trim();
+    if (!systemPrefix) return clampPromptLength(latestUserPrompt);
+    const userSection = `User request:\n${latestUserPrompt}`;
+    const withSystem = `System instructions:\n${systemPrefix}\n\n${userSection}`;
+    if (withSystem.length <= XAI_IMAGE_PROMPT_MAX_CHARS) return withSystem;
+    const systemPrefixLabel = "System instructions:\n";
+    const userSectionPrefix = `\n\n${userSection}`;
+    const availableSystemChars = XAI_IMAGE_PROMPT_MAX_CHARS - systemPrefixLabel.length - userSectionPrefix.length;
+    if (availableSystemChars <= 0) return clampPromptLength(userSection);
+    const truncatedSystem = systemPrefix.slice(0, availableSystemChars);
+    return `${systemPrefixLabel}${truncatedSystem}${userSectionPrefix}`;
+}
+async function readErrorResponse(response) {
+    const body = await response.text();
+    if (!body.trim()) return `xAI image generation request failed with status ${response.status}.`;
+    try {
+        const parsed = JSON.parse(body);
+        const errorRecord = parsed.error && "object" == typeof parsed.error ? parsed.error : void 0;
+        const message = "string" == typeof errorRecord?.message && errorRecord.message || "string" == typeof parsed.message && parsed.message || "string" == typeof parsed.error && parsed.error;
+        if (message) return `xAI image generation failed: ${message}`;
+    } catch  {}
+    return `xAI image generation failed: ${body}`;
+}
+class NativeXAIImageModel extends BaseChatModel {
+    bindTools(_tools, _options) {
+        return this;
+    }
+    _llmType() {
+        return "xai-image-native";
+    }
+    getLsParams() {
+        return {
+            ls_provider: "xai",
+            ls_model_name: this.model,
+            ls_model_type: "chat"
+        };
+    }
+    invocationParams() {
+        return {
+            provider: "xai",
+            model: this.model,
+            baseURL: this.baseURL,
+            responseFormat: this.responseFormat,
+            size: this.size
+        };
+    }
+    async _generate(messages, options, _runManager) {
+        if (!this.apiKey) throw new Error("Missing xAI credentials. Configure XAI_API_KEY before using grok-imagine-image.");
+        const prompt = buildPrompt(messages);
+        const payload = {
+            model: this.model,
+            prompt,
+            response_format: this.responseFormat
+        };
+        if (this.size) payload.size = this.size;
+        const response = await this.caller.callWithOptions({
+            signal: options.signal
+        }, async ()=>fetch(`${this.baseURL}/images/generations`, {
+                method: "POST",
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                    "Content-Type": "application/json"
+                },
+                body: JSON.stringify(payload),
+                signal: options.signal
+            }));
+        if (!response.ok) throw new Error(await readErrorResponse(response));
+        const data = await response.json();
+        const first = Array.isArray(data.data) ? data.data[0] : void 0;
+        if (!first) throw new Error("xAI image generation returned no image data.");
+        const imageUrl = "string" == typeof first.url && first.url.trim() ? first.url.trim() : "string" == typeof first.b64_json && first.b64_json.trim() ? `data:${first.mime_type || "image/png"};base64,${first.b64_json.trim()}` : "";
+        if (!imageUrl) throw new Error("xAI image generation response was missing both url and b64_json.");
+        const confirmationText = "Image generated.";
+        const message = new AIMessage({
+            content: [
+                {
+                    type: "text",
+                    text: confirmationText
+                },
+                {
+                    type: "output_image",
+                    image_url: imageUrl
+                }
+            ],
+            response_metadata: {
+                model: this.model,
+                revised_prompt: first.revised_prompt
+            }
+        });
+        return {
+            generations: [
+                {
+                    text: confirmationText,
+                    message
+                }
+            ],
+            llmOutput: {
+                model: this.model
+            }
+        };
+    }
+    async *_streamResponseChunks(messages, options, runManager) {
+        const result = await this._generate(messages, options, runManager);
+        const generation = result.generations[0];
+        if (!generation) return;
+        const aiMessage = generation.message;
+        const chunk = new AIMessageChunk({
+            content: aiMessage.content,
+            additional_kwargs: aiMessage.additional_kwargs,
+            response_metadata: aiMessage.response_metadata
+        });
+        if (generation.text) await runManager?.handleLLMNewToken(generation.text);
+        yield new ChatGenerationChunk({
+            text: generation.text || "",
+            message: chunk,
+            generationInfo: generation.generationInfo
+        });
+    }
+    constructor(fields){
+        super(fields), _define_property(this, "model", void 0), _define_property(this, "apiKey", void 0), _define_property(this, "baseURL", void 0), _define_property(this, "size", void 0), _define_property(this, "responseFormat", void 0);
+        this.model = fields.model;
+        this.apiKey = fields.apiKey;
+        this.baseURL = (fields.baseURL || DEFAULT_XAI_BASE_URL).replace(/\/+$/, "");
+        this.size = fields.size;
+        this.responseFormat = fields.responseFormat || "url";
+    }
+}
+export { DEFAULT_XAI_BASE_URL, NativeXAIImageModel, isNativeXAIImageModel };

package/dist/agent/tests/mcpClientManager.test.cjs

@@ -167,6 +167,122 @@ const getClientConfig = (manager)=>manager.buildClientConfig();
         (0, external_vitest_namespaceObject.expect)(server.env.INVARIANT_API_URL).toBe("https://explorer.invariantlabs.ai");
         (0, external_vitest_namespaceObject.expect)(server.env.GUARDRAILS_API_URL).toBe("https://explorer.invariantlabs.ai");
     });
+    (0, external_vitest_namespaceObject.it)("keeps MCP multimodal output handling in artifact mode", ()=>{
+        const configs = [
+            {
+                servers: [
+                    {
+                        name: "fal-ai",
+                        transport: "stdio",
+                        command: "bun",
+                        args: [
+                            "run",
+                            "src/tools/mcp-fal-ai.ts"
+                        ]
+                    }
+                ]
+            }
+        ];
+        const manager = new mcpClientManager_cjs_namespaceObject.MCPClientManager(configs, testLogger);
+        const clientConfig = getClientConfig(manager);
+        (0, external_vitest_namespaceObject.expect)(clientConfig.outputHandling).toEqual({
+            image: "artifact",
+            audio: "artifact",
+            resource: "artifact"
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("lists resources from MCP client", async ()=>{
+        const listResources = external_vitest_namespaceObject.vi.fn().mockResolvedValue({
+            fal: [
+                {
+                    uri: "fal://jobs/123",
+                    name: "Job 123",
+                    description: "Generated asset",
+                    mimeType: "application/json"
+                }
+            ]
+        });
+        const manager = new mcpClientManager_cjs_namespaceObject.MCPClientManager([], testLogger);
+        manager.client = {
+            listResources
+        };
+        const result = await manager.listResources([
+            "fal"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(listResources).toHaveBeenCalledWith("fal");
+        (0, external_vitest_namespaceObject.expect)(result).toEqual({
+            fal: [
+                {
+                    uri: "fal://jobs/123",
+                    name: "Job 123",
+                    description: "Generated asset",
+                    mimeType: "application/json"
+                }
+            ]
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("lists resource templates from MCP client", async ()=>{
+        const listResourceTemplates = external_vitest_namespaceObject.vi.fn().mockResolvedValue({
+            fal: [
+                {
+                    uriTemplate: "fal://jobs/{jobId}",
+                    name: "Fal Job",
+                    description: "Job by ID",
+                    mimeType: "application/json"
+                }
+            ]
+        });
+        const manager = new mcpClientManager_cjs_namespaceObject.MCPClientManager([], testLogger);
+        manager.client = {
+            listResourceTemplates
+        };
+        const result = await manager.listResourceTemplates([
+            "fal"
+        ]);
+        (0, external_vitest_namespaceObject.expect)(listResourceTemplates).toHaveBeenCalledWith("fal");
+        (0, external_vitest_namespaceObject.expect)(result).toEqual({
+            fal: [
+                {
+                    uriTemplate: "fal://jobs/{jobId}",
+                    name: "Fal Job",
+                    description: "Job by ID",
+                    mimeType: "application/json"
+                }
+            ]
+        });
+    });
+    (0, external_vitest_namespaceObject.it)("reads resources from MCP client", async ()=>{
+        const readResource = external_vitest_namespaceObject.vi.fn().mockResolvedValue([
+            {
+                uri: "fal://jobs/123",
+                mimeType: "application/json",
+                text: '{"status":"completed"}'
+            }
+        ]);
+        const manager = new mcpClientManager_cjs_namespaceObject.MCPClientManager([], testLogger);
+        manager.client = {
+            readResource
+        };
+        const result = await manager.readResource("fal", "fal://jobs/123");
+        (0, external_vitest_namespaceObject.expect)(readResource).toHaveBeenCalledWith("fal", "fal://jobs/123");
+        (0, external_vitest_namespaceObject.expect)(result).toEqual([
+            {
+                uri: "fal://jobs/123",
+                mimeType: "application/json",
+                text: '{"status":"completed"}'
+            }
+        ]);
+    });
+    (0, external_vitest_namespaceObject.it)("calls close on cleanup", async ()=>{
+        const close = external_vitest_namespaceObject.vi.fn().mockResolvedValue(void 0);
+        const manager = new mcpClientManager_cjs_namespaceObject.MCPClientManager([], testLogger);
+        manager.client = {
+            close
+        };
+        await manager.cleanup();
+        (0, external_vitest_namespaceObject.expect)(close).toHaveBeenCalledTimes(1);
+        (0, external_vitest_namespaceObject.expect)(manager.client).toBeNull();
+    });
 });
 for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {

package/dist/agent/tests/mcpClientManager.test.js

@@ -1,4 +1,4 @@
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { MCPClientManager } from "../config/mcpClientManager.js";
 const testLogger = {
     debug: ()=>{},
@@ -165,4 +165,120 @@ describe("MCPClientManager runtime env", ()=>{
         expect(server.env.INVARIANT_API_URL).toBe("https://explorer.invariantlabs.ai");
         expect(server.env.GUARDRAILS_API_URL).toBe("https://explorer.invariantlabs.ai");
     });
+    it("keeps MCP multimodal output handling in artifact mode", ()=>{
+        const configs = [
+            {
+                servers: [
+                    {
+                        name: "fal-ai",
+                        transport: "stdio",
+                        command: "bun",
+                        args: [
+                            "run",
+                            "src/tools/mcp-fal-ai.ts"
+                        ]
+                    }
+                ]
+            }
+        ];
+        const manager = new MCPClientManager(configs, testLogger);
+        const clientConfig = getClientConfig(manager);
+        expect(clientConfig.outputHandling).toEqual({
+            image: "artifact",
+            audio: "artifact",
+            resource: "artifact"
+        });
+    });
+    it("lists resources from MCP client", async ()=>{
+        const listResources = vi.fn().mockResolvedValue({
+            fal: [
+                {
+                    uri: "fal://jobs/123",
+                    name: "Job 123",
+                    description: "Generated asset",
+                    mimeType: "application/json"
+                }
+            ]
+        });
+        const manager = new MCPClientManager([], testLogger);
+        manager.client = {
+            listResources
+        };
+        const result = await manager.listResources([
+            "fal"
+        ]);
+        expect(listResources).toHaveBeenCalledWith("fal");
+        expect(result).toEqual({
+            fal: [
+                {
+                    uri: "fal://jobs/123",
+                    name: "Job 123",
+                    description: "Generated asset",
+                    mimeType: "application/json"
+                }
+            ]
+        });
+    });
+    it("lists resource templates from MCP client", async ()=>{
+        const listResourceTemplates = vi.fn().mockResolvedValue({
+            fal: [
+                {
+                    uriTemplate: "fal://jobs/{jobId}",
+                    name: "Fal Job",
+                    description: "Job by ID",
+                    mimeType: "application/json"
+                }
+            ]
+        });
+        const manager = new MCPClientManager([], testLogger);
+        manager.client = {
+            listResourceTemplates
+        };
+        const result = await manager.listResourceTemplates([
+            "fal"
+        ]);
+        expect(listResourceTemplates).toHaveBeenCalledWith("fal");
+        expect(result).toEqual({
+            fal: [
+                {
+                    uriTemplate: "fal://jobs/{jobId}",
+                    name: "Fal Job",
+                    description: "Job by ID",
+                    mimeType: "application/json"
+                }
+            ]
+        });
+    });
+    it("reads resources from MCP client", async ()=>{
+        const readResource = vi.fn().mockResolvedValue([
+            {
+                uri: "fal://jobs/123",
+                mimeType: "application/json",
+                text: '{"status":"completed"}'
+            }
+        ]);
+        const manager = new MCPClientManager([], testLogger);
+        manager.client = {
+            readResource
+        };
+        const result = await manager.readResource("fal", "fal://jobs/123");
+        expect(readResource).toHaveBeenCalledWith("fal", "fal://jobs/123");
+        expect(result).toEqual([
+            {
+                uri: "fal://jobs/123",
+                mimeType: "application/json",
+                text: '{"status":"completed"}'
+            }
+        ]);
+    });
+    it("calls close on cleanup", async ()=>{
+        const close = vi.fn().mockResolvedValue(void 0);
+        const manager = new MCPClientManager([], testLogger);
+        manager.client = {
+            close
+        };
+        await manager.cleanup();
+        expect(close).toHaveBeenCalledTimes(1);
+        expect(manager.client).toBeNull();
+    });
 });

package/dist/agent/tests/mcpResourceTools.test.cjs

@@ -0,0 +1,101 @@
+"use strict";
+var __webpack_exports__ = {};
+const external_vitest_namespaceObject = require("vitest");
+const mcp_resources_cjs_namespaceObject = require("../tools/mcp_resources.cjs");
+const createManagerStub = ()=>{
+    const listResources = external_vitest_namespaceObject.vi.fn();
+    const listResourceTemplates = external_vitest_namespaceObject.vi.fn();
+    const readResource = external_vitest_namespaceObject.vi.fn();
+    const manager = {
+        listResources,
+        listResourceTemplates,
+        readResource
+    };
+    return {
+        manager,
+        listResources,
+        listResourceTemplates,
+        readResource
+    };
+};
+(0, external_vitest_namespaceObject.describe)("mcp resource tools", ()=>{
+    (0, external_vitest_namespaceObject.it)("lists resources and templates", async ()=>{
+        const { manager, listResources, listResourceTemplates } = createManagerStub();
+        listResources.mockResolvedValue({
+            fal: [
+                {
+                    uri: "fal://jobs/1",
+                    name: "Job 1",
+                    mimeType: "application/json"
+                }
+            ]
+        });
+        listResourceTemplates.mockResolvedValue({
+            fal: [
+                {
+                    uriTemplate: "fal://jobs/{id}",
+                    name: "Job by id"
+                }
+            ]
+        });
+        const [listTool] = (0, mcp_resources_cjs_namespaceObject.createMCPResourceTools)(manager);
+        const output = await listTool.invoke({
+            includeTemplates: true
+        });
+        const parsed = JSON.parse(String(output));
+        (0, external_vitest_namespaceObject.expect)(listResources).toHaveBeenCalledWith([]);
+        (0, external_vitest_namespaceObject.expect)(listResourceTemplates).toHaveBeenCalledWith([]);
+        (0, external_vitest_namespaceObject.expect)(parsed.resourceCount).toBe(1);
+        (0, external_vitest_namespaceObject.expect)(parsed.resourceTemplateCount).toBe(1);
+        (0, external_vitest_namespaceObject.expect)(parsed.resources.fal[0].uri).toBe("fal://jobs/1");
+    });
+    (0, external_vitest_namespaceObject.it)("reads resource content without inlining binary blobs by default", async ()=>{
+        const { manager, readResource } = createManagerStub();
+        readResource.mockResolvedValue([
+            {
+                uri: "fal://jobs/1",
+                mimeType: "application/json",
+                text: "abcdefghijklmnopqrstuvwxyz",
+                blob: "YWJjZA=="
+            }
+        ]);
+        const tools = (0, mcp_resources_cjs_namespaceObject.createMCPResourceTools)(manager);
+        const readTool = tools.find((entry)=>"mcp_read_resource" === entry.name);
+        if (!readTool) throw new Error("mcp_read_resource tool missing");
+        const output = await readTool.invoke({
+            server: "fal",
+            uri: "fal://jobs/1",
+            maxTextChars: 10
+        });
+        const parsed = JSON.parse(String(output));
+        (0, external_vitest_namespaceObject.expect)(readResource).toHaveBeenCalledWith("fal", "fal://jobs/1");
+        (0, external_vitest_namespaceObject.expect)(parsed.content[0].text).toBe("abcdefghij");
+        (0, external_vitest_namespaceObject.expect)(parsed.content[0].truncated).toBe(true);
+        (0, external_vitest_namespaceObject.expect)(parsed.content[0].blobLength).toBe(8);
+        (0, external_vitest_namespaceObject.expect)(parsed.content[0].blob).toBeUndefined();
+    });
+    (0, external_vitest_namespaceObject.it)("can include binary blobs when requested", async ()=>{
+        const { manager, readResource } = createManagerStub();
+        readResource.mockResolvedValue([
+            {
+                uri: "fal://jobs/2",
+                mimeType: "image/png",
+                blob: "YWJjZA=="
+            }
+        ]);
+        const tools = (0, mcp_resources_cjs_namespaceObject.createMCPResourceTools)(manager);
+        const readTool = tools.find((entry)=>"mcp_read_resource" === entry.name);
+        if (!readTool) throw new Error("mcp_read_resource tool missing");
+        const output = await readTool.invoke({
+            server: "fal",
+            uri: "fal://jobs/2",
+            includeBinary: true
+        });
+        const parsed = JSON.parse(String(output));
+        (0, external_vitest_namespaceObject.expect)(parsed.content[0].blob).toBe("YWJjZA==");
+    });
+});
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/agent/tests/mcpResourceTools.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/agent/tests/mcpResourceTools.test.js

@@ -0,0 +1,95 @@
+import { describe, expect, it, vi } from "vitest";
+import { createMCPResourceTools } from "../tools/mcp_resources.js";
+const createManagerStub = ()=>{
+    const listResources = vi.fn();
+    const listResourceTemplates = vi.fn();
+    const readResource = vi.fn();
+    const manager = {
+        listResources,
+        listResourceTemplates,
+        readResource
+    };
+    return {
+        manager,
+        listResources,
+        listResourceTemplates,
+        readResource
+    };
+};
+describe("mcp resource tools", ()=>{
+    it("lists resources and templates", async ()=>{
+        const { manager, listResources, listResourceTemplates } = createManagerStub();
+        listResources.mockResolvedValue({
+            fal: [
+                {
+                    uri: "fal://jobs/1",
+                    name: "Job 1",
+                    mimeType: "application/json"
+                }
+            ]
+        });
+        listResourceTemplates.mockResolvedValue({
+            fal: [
+                {
+                    uriTemplate: "fal://jobs/{id}",
+                    name: "Job by id"
+                }
+            ]
+        });
+        const [listTool] = createMCPResourceTools(manager);
+        const output = await listTool.invoke({
+            includeTemplates: true
+        });
+        const parsed = JSON.parse(String(output));
+        expect(listResources).toHaveBeenCalledWith([]);
+        expect(listResourceTemplates).toHaveBeenCalledWith([]);
+        expect(parsed.resourceCount).toBe(1);
+        expect(parsed.resourceTemplateCount).toBe(1);
+        expect(parsed.resources.fal[0].uri).toBe("fal://jobs/1");
+    });
+    it("reads resource content without inlining binary blobs by default", async ()=>{
+        const { manager, readResource } = createManagerStub();
+        readResource.mockResolvedValue([
+            {
+                uri: "fal://jobs/1",
+                mimeType: "application/json",
+                text: "abcdefghijklmnopqrstuvwxyz",
+                blob: "YWJjZA=="
+            }
+        ]);
+        const tools = createMCPResourceTools(manager);
+        const readTool = tools.find((entry)=>"mcp_read_resource" === entry.name);
+        if (!readTool) throw new Error("mcp_read_resource tool missing");
+        const output = await readTool.invoke({
+            server: "fal",
+            uri: "fal://jobs/1",
+            maxTextChars: 10
+        });
+        const parsed = JSON.parse(String(output));
+        expect(readResource).toHaveBeenCalledWith("fal", "fal://jobs/1");
+        expect(parsed.content[0].text).toBe("abcdefghij");
+        expect(parsed.content[0].truncated).toBe(true);
+        expect(parsed.content[0].blobLength).toBe(8);
+        expect(parsed.content[0].blob).toBeUndefined();
+    });
+    it("can include binary blobs when requested", async ()=>{
+        const { manager, readResource } = createManagerStub();
+        readResource.mockResolvedValue([
+            {
+                uri: "fal://jobs/2",
+                mimeType: "image/png",
+                blob: "YWJjZA=="
+            }
+        ]);
+        const tools = createMCPResourceTools(manager);
+        const readTool = tools.find((entry)=>"mcp_read_resource" === entry.name);
+        if (!readTool) throw new Error("mcp_read_resource tool missing");
+        const output = await readTool.invoke({
+            server: "fal",
+            uri: "fal://jobs/2",
+            includeBinary: true
+        });
+        const parsed = JSON.parse(String(output));
+        expect(parsed.content[0].blob).toBe("YWJjZA==");
+    });
+});