@pripanggalih/clickup-mcp 1.6.1

package/dist/index.js

@@ -0,0 +1,135 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serverPromise = void 0;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const config_1 = require("./shared/config");
+const utils_1 = require("./shared/utils");
+// Import tool registration functions
+const task_tools_1 = require("./tools/task-tools");
+const task_write_tools_1 = require("./tools/task-write-tools");
+const search_tools_1 = require("./tools/search-tools");
+const space_tools_1 = require("./tools/space-tools");
+const list_tools_1 = require("./tools/list-tools");
+const time_tools_1 = require("./tools/time-tools");
+const doc_tools_1 = require("./tools/doc-tools");
+const admin_tools_1 = require("./tools/admin-tools");
+const space_resources_1 = require("./resources/space-resources");
+// Create server variable that will be initialized later
+let server;
+// Register tools based on mode with user data for enhanced documentation
+async function initializeServer() {
+    console.error(`Starting ClickUp MCP in ${config_1.CONFIG.mode} mode`);
+    // Fetch current user and spaces for enhanced tool documentation and API health check
+    const [userData, spacesIndex] = await Promise.all([
+        (0, utils_1.getCurrentUser)(),
+        (0, utils_1.getSpaceSearchIndex)()
+    ]);
+    const spaces = spacesIndex._docs || [];
+    console.error(`Connected as: ${userData.user.username} (${userData.user.email})`);
+    // Filter out archived spaces and format as simple list
+    const activeSpaces = spaces.filter((s) => !s.archived);
+    const formattedSpaces = activeSpaces
+        .map((s) => `- ${s.name} (space_id: ${s.id})`)
+        .join('\n');
+    const instructions = [
+        `ClickUp is a Ticket system. It is used to track tasks, bugs, and other work items.`,
+        `Is you are asked for infos about projects or tasks, search for tasks or documents in ClickUp (this MCP) first.`,
+        `The following spaces/projects are available:`,
+        formattedSpaces
+    ].join('\n');
+    console.error(`Pre-loaded ${activeSpaces.length} active spaces`);
+    // Create the MCP server with instructions
+    server = new mcp_js_1.McpServer({
+        name: "Clickup MCP",
+        version: require('../package.json').version,
+    }, {
+        instructions
+    });
+    // Register prompts
+    const lang = config_1.CONFIG.primaryLanguageHint === 'de' ? 'de' : 'en';
+    // Register "my-todos" prompt
+    server.registerPrompt("my-todos", {
+        title: lang === 'de' ? "Meine TODOs" : "My TODOs",
+        description: lang === 'de'
+            ? "Meine aktuellen TODO-Aufgaben aus ClickUp abrufen und nach Priorität kategorisiert analysieren"
+            : "Get and analyze my current TODO tasks from ClickUp, categorized by priority"
+    }, () => {
+        const messages = [{
+                role: "user",
+                content: {
+                    type: "text",
+                    text: lang === 'de'
+                        ? `Kannst du in ClickUp nachsehen, was meine aktuellen TODOs sind? Bitte suche nach allen offenen Aufgaben, die mir zugewiesen sind, analysiere deren Inhalt und kategorisiere sie nach erkennbarer Priorität (dringend, hoch, normal, niedrig). Für jede Kategorie gib eine kurze Zusammenfassung dessen, was getan werden muss und hebe Fälligkeitstermine oder wichtige Details aus den Aufgabenbeschreibungen hervor.
+
+Bitte strukturiere deine Antwort mit:
+1. **Zusammenfassung**: Gesamtanzahl der Aufgaben und allgemeine Prioritätsverteilung
+2. **Dringende Aufgaben**: Aufgaben, die sofortige Aufmerksamkeit benötigen (heute fällig, überfällig oder als dringend markiert)
+3. **Hohe Priorität**: Wichtige Aufgaben, die bald erledigt werden sollten
+4. **Normale Priorität**: Regelmäßige Aufgaben, die später geplant werden können
+5. **Niedrige Priorität**: Aufgaben, die erledigt werden können, wenn Zeit vorhanden ist
+6. **Empfehlungen**: Vorgeschlagene Maßnahmen oder Prioritäten für den kommenden Zeitraum
+
+Verwende die ClickUp-Suchtools, um mir zugewiesene Aufgaben zu finden, und hole detaillierte Informationen über die wichtigsten mit getTaskById.`
+                        : `Can you look into ClickUp and check what my current TODO's are? Please search for all open tasks assigned to me, analyze their content, and categorize them by apparent priority (urgent, high, normal, low). For each category, provide a brief summary of what needs to be done and highlight any due dates or important details from the task descriptions.
+
+Please structure your response with:
+1. **Summary**: Total number of tasks and overall priority distribution
+2. **Urgent Tasks**: Tasks that need immediate attention (due today, overdue, or marked as urgent)
+3. **High Priority**: Important tasks that should be addressed soon
+4. **Normal Priority**: Regular tasks that can be scheduled for later
+5. **Low Priority**: Tasks that can be done when time permits
+6. **Recommendations**: Suggested actions or priorities for the upcoming period
+
+Use the ClickUp search tools to find tasks assigned to me, and get detailed information about the most important ones using getTaskById.`
+                }
+            }];
+        return { messages };
+    });
+    if (config_1.CONFIG.mode === 'read-minimal') {
+        // Core task context tools for AI coding assistance
+        // Only getTaskById and searchTasks
+        (0, task_tools_1.registerTaskToolsRead)(server, userData);
+        (0, search_tools_1.registerSearchTools)(server, userData);
+    }
+    else if (config_1.CONFIG.mode === 'read') {
+        // All read-only tools
+        (0, task_tools_1.registerTaskToolsRead)(server, userData);
+        (0, search_tools_1.registerSearchTools)(server, userData);
+        (0, space_tools_1.registerSpaceTools)(server);
+        (0, space_resources_1.registerSpaceResources)(server);
+        (0, list_tools_1.registerListToolsRead)(server);
+        (0, time_tools_1.registerTimeToolsRead)(server);
+        (0, doc_tools_1.registerDocumentToolsRead)(server);
+    }
+    else if (config_1.CONFIG.mode === 'write') {
+        // All tools (full functionality)
+        (0, task_tools_1.registerTaskToolsRead)(server, userData);
+        (0, task_write_tools_1.registerTaskToolsWrite)(server, userData);
+        (0, search_tools_1.registerSearchTools)(server, userData);
+        (0, space_tools_1.registerSpaceTools)(server);
+        (0, space_resources_1.registerSpaceResources)(server);
+        (0, list_tools_1.registerListToolsRead)(server);
+        (0, list_tools_1.registerListToolsWrite)(server);
+        (0, time_tools_1.registerTimeToolsRead)(server);
+        (0, time_tools_1.registerTimeToolsWrite)(server);
+        (0, doc_tools_1.registerDocumentToolsRead)(server);
+        (0, doc_tools_1.registerDocumentToolsWrite)(server);
+        (0, admin_tools_1.registerAdminToolsWrite)(server);
+    }
+    return server;
+}
+// Initialize server with enhanced documentation and export
+const serverPromise = initializeServer();
+exports.serverPromise = serverPromise;
+// Only connect to the transport if this file is being run directly (not imported)
+// OR if not being imported by CLI (to support Claude Desktop's module loading)
+const isCliMode = process.argv.some(arg => arg.includes('cli.ts') || arg.includes('cli.js'));
+if (require.main === module || !isCliMode) {
+    // Start receiving messages on stdin and sending messages on stdout after initialization
+    serverPromise.then(() => {
+        const transport = new stdio_js_1.StdioServerTransport();
+        server.connect(transport);
+    }).catch(console.error);
+}

package/dist/resources/space-resources.d.ts

@@ -0,0 +1,6 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * Register ClickUp space resources using resource templates for dynamic discovery
+ */
+export declare function registerSpaceResources(server: McpServer): void;
+//# sourceMappingURL=space-resources.d.ts.map

package/dist/resources/space-resources.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"space-resources.d.ts","sourceRoot":"","sources":["../../src/resources/space-resources.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAoB,MAAM,yCAAyC,CAAC;AAiBtF;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,SAAS,QAwFvD"}

package/dist/resources/space-resources.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerSpaceResources = registerSpaceResources;
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const utils_1 = require("../shared/utils");
+/**
+ * Extract space ID from clickup:// URI
+ */
+function extractSpaceIdFromUri(uriString) {
+    try {
+        const url = new URL(uriString);
+        const pathParts = url.pathname.split('/');
+        return pathParts[pathParts.length - 1];
+    }
+    catch (error) {
+        throw new Error(`Invalid ClickUp space URI: ${uriString}`);
+    }
+}
+/**
+ * Register ClickUp space resources using resource templates for dynamic discovery
+ */
+function registerSpaceResources(server) {
+    // Create resource template for ClickUp spaces
+    const spaceTemplate = new mcp_js_1.ResourceTemplate("clickup://space/{spaceId}", {
+        list: async () => {
+            try {
+                const searchIndex = await (0, utils_1.getSpaceSearchIndex)();
+                if (!searchIndex) {
+                    return { resources: [] };
+                }
+                const spaces = searchIndex._docs || [];
+                // Filter out archived spaces for resource listing
+                const activeSpaces = spaces.filter((space) => !space.archived);
+                return {
+                    resources: activeSpaces.map((space) => ({
+                        uri: `clickup://space/${space.id}`,
+                        name: `${space.name} ClickUp Space.txt`,
+                        title: `${space.name} ClickUp Space`,
+                        mimeType: "text/plain"
+                    }))
+                };
+            }
+            catch (error) {
+                console.error("Error listing space resources:", error);
+                return { resources: [] };
+            }
+        }
+    });
+    // Register resource template for ClickUp spaces
+    server.registerResource("clickup-spaces", spaceTemplate, {
+        title: "ClickUp Spaces",
+        description: "Access ClickUp spaces with their complete structure including lists, folders, and documents",
+    }, async (uri) => {
+        try {
+            const spaceId = extractSpaceIdFromUri(uri.toString());
+            // Fetch space content including lists, folders, and documents
+            const { lists, folders, documents } = await (0, utils_1.getSpaceContent)(spaceId);
+            // Get space details from the search index
+            const searchIndex = await (0, utils_1.getSpaceSearchIndex)();
+            const spaces = searchIndex._docs || [];
+            const space = spaces.find((s) => s.id === spaceId);
+            if (!space) {
+                return {
+                    contents: [{
+                            uri: uri.toString(),
+                            text: `Space with ID ${spaceId} not found.`,
+                        }]
+                };
+            }
+            // Format the content using the shared tree formatting function
+            const treeContent = (0, utils_1.formatSpaceTree)(space, lists, folders, documents);
+            // Add resource metadata
+            const metadata = [
+                '\n---',
+                `ℹ️ Resource last updated: ${new Date().toISOString()}`,
+                `💡 For real-time data, use the searchSpaces tool`
+            ].join('\n');
+            return {
+                contents: [{
+                        uri: uri.toString(),
+                        text: treeContent + metadata,
+                    }]
+            };
+        }
+        catch (error) {
+            console.error("Error reading space resource:", error);
+            return {
+                contents: [{
+                        uri: uri.toString(),
+                        text: `Error reading space: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                    }]
+            };
+        }
+    });
+}

package/dist/shared/config.d.ts

@@ -0,0 +1,11 @@
+export declare const rawPrimaryLang: string | undefined;
+export type McpMode = 'read-minimal' | 'read' | 'write';
+export declare const CONFIG: {
+    apiKey: string;
+    teamId: string;
+    maxImages: number;
+    maxResponseSizeMB: number;
+    primaryLanguageHint: string | undefined;
+    mode: McpMode;
+};
+//# sourceMappingURL=config.d.ts.map

package/dist/shared/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/shared/config.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,cAAc,oBAA2D,CAAC;AAkDvF,MAAM,MAAM,OAAO,GAAG,cAAc,GAAG,MAAM,GAAG,OAAO,CAAC;AAUxD,eAAO,MAAM,MAAM;;;;;;;CAOlB,CAAC"}

package/dist/shared/config.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CONFIG = exports.rawPrimaryLang = void 0;
+exports.rawPrimaryLang = process.env.CLICKUP_PRIMARY_LANGUAGE || process.env.LANG;
+let detectedLanguageHint = undefined;
+/**
+ * Enhanced language detection that handles various formats and common language names
+ */
+function detectLanguage(rawLang) {
+    if (!rawLang)
+        return undefined;
+    const normalizedLang = rawLang.toLowerCase().trim();
+    // German language detection
+    if (normalizedLang === 'de' || normalizedLang === 'german' || normalizedLang === 'deutsch' || normalizedLang.startsWith('de_') || normalizedLang.startsWith('de-')) {
+        return 'de';
+    }
+    // English language detection
+    if (normalizedLang === 'en' || normalizedLang === 'english' || normalizedLang.startsWith('en_') || normalizedLang.startsWith('en-')) {
+        return 'en';
+    }
+    // French language detection
+    if (normalizedLang === 'fr' || normalizedLang === 'french' || normalizedLang === 'français' || normalizedLang.startsWith('fr_') || normalizedLang.startsWith('fr-')) {
+        return 'fr';
+    }
+    // Spanish language detection
+    if (normalizedLang === 'es' || normalizedLang === 'spanish' || normalizedLang === 'español' || normalizedLang.startsWith('es_') || normalizedLang.startsWith('es-')) {
+        return 'es';
+    }
+    // Italian language detection
+    if (normalizedLang === 'it' || normalizedLang === 'italian' || normalizedLang === 'italiano' || normalizedLang.startsWith('it_') || normalizedLang.startsWith('it-')) {
+        return 'it';
+    }
+    // Fallback: extract the primary language part (e.g., 'en' from 'en_US.UTF-8' or 'en-GB')
+    const langPart = normalizedLang.match(/^[a-zA-Z]{2,3}/);
+    if (langPart) {
+        return langPart[0].toLowerCase();
+    }
+    return undefined;
+}
+if (exports.rawPrimaryLang) {
+    detectedLanguageHint = detectLanguage(exports.rawPrimaryLang);
+}
+const rawMode = process.env.CLICKUP_MCP_MODE?.toLowerCase();
+let mcpMode = 'write'; // Default to write (full functionality)
+if (rawMode === 'read-minimal' || rawMode === 'read') {
+    mcpMode = rawMode;
+}
+else if (rawMode && rawMode !== 'write') {
+    console.error(`Invalid CLICKUP_MCP_MODE "${rawMode}". Using default "write". Valid options: read-minimal, read, write`);
+}
+exports.CONFIG = {
+    apiKey: process.env.CLICKUP_API_KEY,
+    teamId: process.env.CLICKUP_TEAM_ID,
+    maxImages: process.env.MAX_IMAGES ? parseInt(process.env.MAX_IMAGES) : 4,
+    maxResponseSizeMB: process.env.MAX_RESPONSE_SIZE_MB ? parseFloat(process.env.MAX_RESPONSE_SIZE_MB) : 1,
+    primaryLanguageHint: detectedLanguageHint, // Store the cleaned code directly
+    mode: mcpMode,
+};
+if (!exports.CONFIG.apiKey || !exports.CONFIG.teamId) {
+    throw new Error("Missing Clickup API key or team ID");
+}

package/dist/shared/data-uri.d.ts

@@ -0,0 +1,14 @@
+export interface ParsedDataUri {
+    mimeType: string;
+    base64Data: string;
+}
+/**
+ * Parse data URI strings of the form data:mime/type;base64,....
+ * Returns null if the value is not a base64 data URI.
+ */
+export declare function parseDataUri(dataUri: string): ParsedDataUri | null;
+/**
+ * Estimate the decoded byte-size of base64 data without allocating buffers
+ */
+export declare function estimateBase64Size(base64Data: string): number;
+//# sourceMappingURL=data-uri.d.ts.map

package/dist/shared/data-uri.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"data-uri.d.ts","sourceRoot":"","sources":["../../src/shared/data-uri.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa;IAC5B,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;GAGG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAoBlE;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAI7D"}

package/dist/shared/data-uri.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDataUri = parseDataUri;
+exports.estimateBase64Size = estimateBase64Size;
+/**
+ * Parse data URI strings of the form data:mime/type;base64,....
+ * Returns null if the value is not a base64 data URI.
+ */
+function parseDataUri(dataUri) {
+    if (!dataUri.startsWith("data:")) {
+        return null;
+    }
+    const match = dataUri.match(/^data:([^;]+);base64,(.+)$/s);
+    if (!match) {
+        return null;
+    }
+    const [, mimeType, base64Part] = match;
+    const sanitizedBase64 = base64Part.replace(/\s+/g, "");
+    if (!sanitizedBase64) {
+        return null;
+    }
+    return {
+        mimeType,
+        base64Data: sanitizedBase64,
+    };
+}
+/**
+ * Estimate the decoded byte-size of base64 data without allocating buffers
+ */
+function estimateBase64Size(base64Data) {
+    const sanitized = base64Data.replace(/\s+/g, "");
+    const padding = sanitized.endsWith("==") ? 2 : sanitized.endsWith("=") ? 1 : 0;
+    return Math.max(0, (sanitized.length * 3) / 4 - padding);
+}

package/dist/shared/image-processing.d.ts

@@ -0,0 +1,13 @@
+import { ContentBlock, ImageMetadataBlock } from "./types";
+/**
+ * Downloads images from image_metadata blocks and applies smart size/count limiting
+ * Prioritizes keeping the most recent images (assumes content is ordered with newest items last)
+ * Uses intelligent size calculation accounting for text content
+ *
+ * @param content Array of content blocks that may contain image_metadata blocks
+ * @param maxImages Maximum number of images to keep (defaults to CONFIG.maxImages)
+ * @param maxSizeMB Maximum response size in MB (defaults to CONFIG.maxResponseSizeMB)
+ * @returns Promise resolving to content array with downloaded images or placeholders
+ */
+export declare function downloadImages(content: (ContentBlock | ImageMetadataBlock)[], maxImages?: number, maxSizeMB?: number): Promise<ContentBlock[]>;
+//# sourceMappingURL=image-processing.d.ts.map

package/dist/shared/image-processing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"image-processing.d.ts","sourceRoot":"","sources":["../../src/shared/image-processing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAE,kBAAkB,EAAC,MAAM,SAAS,CAAC;AAmDzD;;;;;;;;;GASG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,CAAC,YAAY,GAAG,kBAAkB,CAAC,EAAE,EAAE,SAAS,GAAE,MAAyB,EAAE,SAAS,GAAE,MAAiC,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CA0BhM"}

package/dist/shared/image-processing.js

@@ -0,0 +1,199 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.downloadImages = downloadImages;
+const config_1 = require("./config");
+const data_uri_1 = require("./data-uri");
+const buffer_1 = require("buffer");
+/**
+ * Detect MIME type from image binary data using magic bytes (file signatures)
+ * Returns null if the format is not recognized
+ */
+function detectMimeTypeFromBuffer(buffer) {
+    const bytes = new Uint8Array(buffer);
+    if (bytes.length < 12)
+        return null;
+    // PNG: 89 50 4E 47 (‰PNG)
+    if (bytes[0] === 0x89 && bytes[1] === 0x50 && bytes[2] === 0x4E && bytes[3] === 0x47) {
+        return "image/png";
+    }
+    // JPEG: FF D8 FF
+    if (bytes[0] === 0xFF && bytes[1] === 0xD8 && bytes[2] === 0xFF) {
+        return "image/jpeg";
+    }
+    // GIF: 47 49 46 38 (GIF8)
+    if (bytes[0] === 0x47 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x38) {
+        return "image/gif";
+    }
+    // WebP: RIFF....WEBP
+    if (bytes[0] === 0x52 && bytes[1] === 0x49 && bytes[2] === 0x46 && bytes[3] === 0x46 &&
+        bytes[8] === 0x57 && bytes[9] === 0x45 && bytes[10] === 0x42 && bytes[11] === 0x50) {
+        return "image/webp";
+    }
+    return null;
+}
+/**
+ * Detect MIME type from base64-encoded image data
+ * Decodes just enough bytes to check magic numbers
+ */
+function detectMimeTypeFromBase64(base64Data) {
+    // Need at least 16 base64 chars to decode 12 bytes for magic number detection
+    if (base64Data.length < 16)
+        return null;
+    // Create a Uint8Array directly from the decoded bytes to avoid Buffer pooling issues
+    const header = buffer_1.Buffer.from(base64Data.slice(0, 16), "base64");
+    const bytes = new Uint8Array(header);
+    return detectMimeTypeFromBuffer(bytes.buffer);
+}
+/**
+ * Downloads images from image_metadata blocks and applies smart size/count limiting
+ * Prioritizes keeping the most recent images (assumes content is ordered with newest items last)
+ * Uses intelligent size calculation accounting for text content
+ *
+ * @param content Array of content blocks that may contain image_metadata blocks
+ * @param maxImages Maximum number of images to keep (defaults to CONFIG.maxImages)
+ * @param maxSizeMB Maximum response size in MB (defaults to CONFIG.maxResponseSizeMB)
+ * @returns Promise resolving to content array with downloaded images or placeholders
+ */
+async function downloadImages(content, maxImages = config_1.CONFIG.maxImages, maxSizeMB = config_1.CONFIG.maxResponseSizeMB) {
+    // First apply count-based limiting to image_metadata blocks
+    const countLimitedContent = applyCountBasedLimitToImageMetadata(content, maxImages);
+    // Calculate text size to determine available image budget
+    const textContent = countLimitedContent.filter(block => block.type !== "image_metadata");
+    const textSizeBytes = JSON.stringify(textContent).length;
+    const maxSizeBytes = maxSizeMB * 1024 * 1024;
+    const availableImageBudget = Math.max(0, maxSizeBytes - textSizeBytes);
+    // Calculate per-image budget
+    const imageMetadataBlocks = countLimitedContent.filter(block => block.type === "image_metadata");
+    const perImageBudget = imageMetadataBlocks.length > 0 ? availableImageBudget / imageMetadataBlocks.length : 0;
+    // Download images in parallel and replace image_metadata blocks
+    const downloadPromises = countLimitedContent.map(async (block) => {
+        if (block.type === "image_metadata") {
+            if (block.inlineData) {
+                return convertInlineImage(block, perImageBudget);
+            }
+            return await downloadSingleImage(block, perImageBudget);
+        }
+        return block;
+    });
+    return Promise.all(downloadPromises);
+}
+/**
+ * Apply count-based limiting to image_metadata blocks
+ * Keeps the most recent image_metadata blocks (newest last)
+ */
+function applyCountBasedLimitToImageMetadata(content, maxImages) {
+    // Find all image_metadata block indices
+    const imageMetadataIndices = [];
+    content.forEach((block, index) => {
+        if (block.type === "image_metadata") {
+            imageMetadataIndices.push(index);
+        }
+    });
+    // If we have fewer images than the limit, return the original content
+    if (imageMetadataIndices.length <= maxImages) {
+        return content;
+    }
+    // Determine which image_metadata blocks to remove (keep the most recent ones)
+    const imagesToRemove = imageMetadataIndices.slice(0, imageMetadataIndices.length - maxImages);
+    // Create a new content array with excess image_metadata blocks replaced by text placeholders
+    return content.map((block, index) => {
+        if (block.type === "image_metadata" && imagesToRemove.includes(index)) {
+            return {
+                type: "text",
+                text: "[Image removed due to count limitations. Only the most recent images are shown.]",
+            };
+        }
+        return block;
+    });
+}
+/**
+ * Download a single image from an image_metadata block, trying different sizes if needed
+ */
+async function downloadSingleImage(imageMetadata, perImageBudget) {
+    const fallbackText = createImageFallback(imageMetadata);
+    // Try each URL in order (largest to smallest)
+    for (const url of imageMetadata.urls) {
+        const abortController = new AbortController();
+        try {
+            const response = await fetch(url, {
+                signal: abortController.signal
+            });
+            if (!response.ok) {
+                console.error(`Failed to fetch image from ${url}: ${response.status}`);
+                continue;
+            }
+            // Check Content-Length header first to avoid downloading large images
+            const contentLength = response.headers.get("Content-Length");
+            if (contentLength) {
+                const imageSizeBytes = parseInt(contentLength, 10);
+                if (imageSizeBytes > perImageBudget) {
+                    // Cancel the request to stop any ongoing download
+                    abortController.abort();
+                    console.error(`Image from ${url} is ${imageSizeBytes} bytes (from Content-Length), exceeds budget of ${perImageBudget} bytes`);
+                    // Continue to try smaller thumbnail
+                    continue;
+                }
+            }
+            const imageBuffer = await response.arrayBuffer();
+            const actualSizeBytes = imageBuffer.byteLength;
+            // Double-check actual size (in case Content-Length was missing or incorrect)
+            if (actualSizeBytes <= perImageBudget) {
+                // Detect actual MIME type from binary data, fall back to header or default
+                const detectedMimeType = detectMimeTypeFromBuffer(imageBuffer);
+                const mimeType = detectedMimeType || response.headers.get("Content-Type") || "image/png";
+                return {
+                    type: "image",
+                    mimeType,
+                    data: buffer_1.Buffer.from(imageBuffer).toString("base64"),
+                };
+            }
+            else {
+                // Cancel to clean up the connection
+                abortController.abort();
+                console.error(`Image from ${url} is ${actualSizeBytes} bytes (actual size), exceeds budget of ${perImageBudget} bytes`);
+                // Continue to try smaller thumbnail
+            }
+        }
+        catch (error) {
+            if (error.name === 'AbortError') {
+                // Request was cancelled, this is expected - continue to next URL
+                continue;
+            }
+            console.error(`Error fetching image from ${url}: ${error.message || "Unknown error"}`);
+            // Continue to try next URL
+        }
+    }
+    // If all URLs failed or were too large, return fallback text
+    return fallbackText;
+}
+/**
+ * Create a fallback text block when an image cannot be included
+ */
+function createImageFallback(imageMetadata) {
+    return {
+        type: "text",
+        text: `[Image "${imageMetadata.alt}" removed due to size limitations.]`,
+    };
+}
+/**
+ * Convert inline image data URIs into image blocks while respecting size budgets
+ */
+function convertInlineImage(imageMetadata, perImageBudget) {
+    const inlineData = imageMetadata.inlineData;
+    if (!inlineData) {
+        return createImageFallback(imageMetadata);
+    }
+    const estimatedSize = (0, data_uri_1.estimateBase64Size)(inlineData.base64Data);
+    if (perImageBudget <= 0 || estimatedSize > perImageBudget) {
+        console.error(`Inline image for "${imageMetadata.alt}" is ${estimatedSize} bytes, exceeds budget of ${perImageBudget} bytes`);
+        return createImageFallback(imageMetadata);
+    }
+    // Detect actual MIME type from binary data, fall back to declared type or default
+    const detectedMimeType = detectMimeTypeFromBase64(inlineData.base64Data);
+    const mimeType = detectedMimeType || inlineData.mimeType || "image/png";
+    return {
+        type: "image",
+        mimeType,
+        data: inlineData.base64Data,
+    };
+}

package/dist/shared/types.d.ts

@@ -0,0 +1,21 @@
+import { CallToolResult } from "@modelcontextprotocol/sdk/types";
+import { ParsedDataUri } from "./data-uri";
+export type ContentBlock = CallToolResult['content'][number];
+export interface ImageMetadataBlock {
+    type: "image_metadata";
+    urls: string[];
+    alt: string;
+    inlineData?: ParsedDataUri;
+}
+export interface DatedContentEvent {
+    date: string;
+    contentBlocks: (ContentBlock | ImageMetadataBlock)[];
+}
+export interface Config {
+    apiKey: string;
+    teamId: string;
+    maxImages: number;
+    maxResponseSizeMB: number;
+    primaryLanguageHint: string | undefined;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/shared/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/shared/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AACjE,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAG3C,MAAM,MAAM,YAAY,GAAG,cAAc,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AAG7D,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;IACZ,UAAU,CAAC,EAAE,aAAa,CAAC;CAC5B;AAGD,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,EAAE,CAAC,YAAY,GAAG,kBAAkB,CAAC,EAAE,CAAC;CACtD;AAGD,MAAM,WAAW,MAAM;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,EAAE,MAAM,CAAC;IAClB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,mBAAmB,EAAE,MAAM,GAAG,SAAS,CAAC;CACzC"}

package/dist/shared/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });