@attrove/mcp 0.1.6 → 0.1.8

package/cjs/tools/meetings.js

@@ -0,0 +1,149 @@
+"use strict";
+/**
+ * Meetings Tool
+ *
+ * MCP tool for listing meetings with AI-generated summaries and action items.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeMeetingsTool = exports.meetingsToolDefinition = void 0;
+/**
+ * MCP schema for discovering and filtering meetings with AI-generated summaries.
+ */
+exports.meetingsToolDefinition = {
+    name: "attrove_meetings",
+    description: `List meetings with AI-generated summaries and action items from the user's own connected accounts.
+
+This read-only tool returns meetings from the authenticated user's authorized meeting integrations (e.g., Google Meet, Zoom, Teams) with AI-generated summaries. Only meetings from services the user has explicitly connected are accessed. Use this when the user asks about:
+- "What happened in my last meeting?"
+- "Summarize yesterday's standup"
+- "What are the action items from the product review?"
+- "Show me my recent meetings"`,
+    inputSchema: {
+        type: "object",
+        properties: {
+            start_date: {
+                type: "string",
+                description: "Start of date range (ISO 8601). If omitted, the server determines the default.",
+            },
+            end_date: {
+                type: "string",
+                description: "End of date range (ISO 8601). If omitted, the server determines the default.",
+            },
+            provider: {
+                type: "string",
+                enum: ["google_meet", "zoom", "teams"],
+                description: "Optional: Filter by meeting provider",
+            },
+            limit: {
+                type: "number",
+                description: "Max meetings to return (default 10, max 50)",
+            },
+        },
+        required: [],
+    },
+    annotations: {
+        title: "Meeting Summaries",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
+};
+/**
+ * Format a meeting's time range for display.
+ * Returns a fallback string when the meeting contains unparseable dates.
+ */
+function formatMeetingTime(meeting) {
+    const start = new Date(meeting.start_time);
+    const end = new Date(meeting.end_time);
+    if (Number.isNaN(start.getTime()) || Number.isNaN(end.getTime())) {
+        return meeting.start_time ?? "Unknown time";
+    }
+    const dateStr = start.toLocaleDateString(undefined, {
+        weekday: "short",
+        month: "short",
+        day: "numeric",
+    });
+    const startTime = start.toLocaleTimeString(undefined, {
+        hour: "numeric",
+        minute: "2-digit",
+    });
+    const endTime = end.toLocaleTimeString(undefined, {
+        hour: "numeric",
+        minute: "2-digit",
+    });
+    return `${dateStr}, ${startTime} – ${endTime}`;
+}
+/**
+ * Fetch meetings via the SDK and format them as a human-readable summary
+ * including AI-generated summaries and action items.
+ */
+async function executeMeetingsTool(client, input) {
+    const options = {
+        expand: ["summary", "short_summary", "action_items", "attendees"],
+    };
+    if (input.start_date) {
+        options.startDate = input.start_date;
+    }
+    if (input.end_date) {
+        options.endDate = input.end_date;
+    }
+    if (input.provider) {
+        options.provider = input.provider;
+    }
+    options.limit = Math.max(1, Math.min(input.limit ?? 10, 50));
+    const response = await client.meetings.list(options);
+    if (!response.data) {
+        // prettier-ignore
+        console.error("[AttroveMCP]", JSON.stringify({ level: "warn", msg: "Meetings API returned success but data was nullish", errorId: "MCP_MEETINGS_MALFORMED_RESPONSE" }));
+        return "The meetings API returned an unexpected response format. Please try again.";
+    }
+    if (response.data.length === 0) {
+        return "No meetings found for the specified date range.";
+    }
+    const meetings = response.data;
+    let result = `Found ${meetings.length} meeting(s):\n`;
+    for (const meeting of meetings) {
+        result += `\n### ${meeting.title}\n`;
+        result += `- **When:** ${formatMeetingTime(meeting)}\n`;
+        if (meeting.provider) {
+            const providerLabel = meeting.provider
+                .replace(/_/g, " ")
+                .replace(/\b\w/g, (c) => c.toUpperCase());
+            result += `- **Provider:** ${providerLabel}\n`;
+        }
+        if (meeting.attendees?.length) {
+            const attendeeList = meeting.attendees
+                .map((a) => {
+                const name = a.name || a.email || "Unknown";
+                const role = a.is_organizer ? " (organizer)" : "";
+                return `${name}${role}`;
+            })
+                .join(", ");
+            result += `- **Attendees:** ${attendeeList}\n`;
+        }
+        if (meeting.meeting_link) {
+            result += `- **Meeting link:** ${meeting.meeting_link}\n`;
+        }
+        if (meeting.summary) {
+            result += `\n**Summary:**\n${meeting.summary}\n`;
+        }
+        else if (meeting.short_summary) {
+            result += `\n**Summary:** ${meeting.short_summary}\n`;
+        }
+        if (meeting.action_items?.length) {
+            result += `\n**Action Items:**\n`;
+            for (const item of meeting.action_items) {
+                const assignee = item.assignee ? ` (${item.assignee})` : "";
+                const dueDate = item.due_date ? ` — due ${item.due_date}` : "";
+                const status = item.completed ? " [Done]" : "";
+                result += `- ${item.description}${assignee}${dueDate}${status}\n`;
+            }
+        }
+    }
+    if (response.pagination?.has_more) {
+        result += `\n_Showing ${meetings.length} of ${response.pagination.total_count ?? "more"} meetings. Adjust start_date, end_date, or limit to refine results._\n`;
+    }
+    return result;
+}
+exports.executeMeetingsTool = executeMeetingsTool;

package/cjs/tools/query.js

@@ -11,15 +11,15 @@ exports.executeQueryTool = exports.queryToolDefinition = void 0;
  */
 exports.queryToolDefinition = {
     name: "attrove_query",
-    description: `Ask a question about the user's communications and get an AI-generated answer.
+    description: `Ask a question and get an AI-generated answer from the user's own connected accounts.
 
-This tool searches across all connected integrations (Gmail, Slack, Google Meet, etc.) and returns a comprehensive answer based on the relevant context.
+This read-only tool searches the authenticated user's connected services (e.g., Gmail, Slack, Google Calendar) and returns an answer based on their own data. Only data the user has explicitly connected and authorized is accessed.
 
 Use this tool when the user asks questions like:
 - "What did Sarah say about the Q4 budget?"
 - "Summarize my meeting with the engineering team"
 - "What are the action items from yesterday's standup?"
-- "When is my next meeting with John?"`,
+- "What context do I need for my 3pm meeting?"`,
     inputSchema: {
         type: "object",
         properties: {
@@ -40,9 +40,16 @@ Use this tool when the user asks questions like:
         },
         required: ["query"],
     },
+    annotations: {
+        title: "Ask Attrove",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
 };
 /**
- * Execute the query tool.
+ * Run a RAG query via the SDK and format the answer with optional sources.
  */
 async function executeQueryTool(client, input) {
     const options = {};
@@ -61,7 +68,7 @@ async function executeQueryTool(client, input) {
             result += `\n- ${source.title}: "${source.snippet}"`;
         }
     }
-    if (response.used_message_ids.length > 0) {
+    if (response.used_message_ids?.length) {
         result += `\n\n_Based on ${response.used_message_ids.length} messages._`;
     }
     return result;

package/cjs/tools/search.js

@@ -12,10 +12,10 @@ const constants_js_1 = require("../constants.js");
  */
 exports.searchToolDefinition = {
     name: "attrove_search",
-    description: `Search for specific messages or conversations in the user's communications.
+    description: `Search for messages or conversations in the user's own connected accounts.
 
-This tool performs semantic search across connected integrations and returns matching messages grouped by conversation. Use this when you need:
-- Raw message data without AI summarization
+This read-only tool performs semantic search across the authenticated user's connected services and returns matching messages grouped by conversation. Only the user's own authorized data is searched. Use this when you need:
+- Message data without AI summarization
 - To find specific conversations or threads
 - To explore what information is available about a topic
 
@@ -45,15 +45,23 @@ Use this tool when the user asks things like:
             },
             include_body_text: {
                 type: "boolean",
-                description: "Optional: Include full message body text",
+                // NOTE: The "200 characters" must match MAX_BODY_PREVIEW_LENGTH in constants.ts
+                description: "Optional: Include message body text preview (truncated to 200 characters)",
                 default: true,
             },
         },
         required: ["query"],
     },
+    annotations: {
+        title: "Search Messages",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: true,
+    },
 };
 /**
- * Execute the search tool.
+ * Search user messages via the SDK and format results grouped by conversation.
  */
 async function executeSearchTool(client, input) {
     const options = {
@@ -85,17 +93,21 @@ async function executeSearchTool(client, input) {
     let skippedThreads = 0;
     let skippedMessages = 0;
     for (const [convId, conv] of Object.entries(response.conversations)) {
-        // Skip malformed conversation entries
+        // Skip malformed conversation entries - may occur with API version mismatches or partial responses
         if (!conv || !conv.threads) {
             skippedConversations++;
+            // prettier-ignore
+            console.error("[AttroveMCP]", JSON.stringify({ level: "warn", msg: "Search skipped malformed conversation", errorId: "MCP_SEARCH_MALFORMED_CONVERSATION", conversationId: convId, hasConv: !!conv, hasThreads: !!(conv?.threads) }));
             continue;
         }
         const convName = conv.conversation_name || `Conversation ${convId}`;
         result += `\n## ${convName}\n`;
         for (const [threadId, messages] of Object.entries(conv.threads)) {
-            // Skip malformed thread entries
+            // Skip malformed thread entries - may occur with API version mismatches or partial responses
             if (!Array.isArray(messages)) {
                 skippedThreads++;
+                // prettier-ignore
+                console.error("[AttroveMCP]", JSON.stringify({ level: "warn", msg: "Search skipped malformed thread", errorId: "MCP_SEARCH_MALFORMED_THREAD", conversationId: convId, threadId, messagesType: typeof messages }));
                 continue;
             }
             if (messages.length > 1) {
@@ -104,6 +116,8 @@ async function executeSearchTool(client, input) {
             for (const msg of messages) {
                 if (!msg) {
                     skippedMessages++;
+                    // prettier-ignore
+                    console.error("[AttroveMCP]", JSON.stringify({ level: "warn", msg: "Search skipped null message", errorId: "MCP_SEARCH_NULL_MESSAGE", conversationId: convId, threadId }));
                     continue;
                 }
                 // Defensive date formatting to handle invalid dates gracefully

package/cjs/transport/http.js

@@ -0,0 +1,192 @@
+"use strict";
+/**
+ * HTTP Transport for Attrove MCP Server
+ *
+ * Provides HTTP-based transport for the MCP server, enabling AI assistants
+ * like ChatGPT to connect via HTTP endpoints instead of stdio.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHttpHandler = void 0;
+const node_crypto_1 = require("node:crypto");
+const streamableHttp_js_1 = require("@modelcontextprotocol/sdk/server/streamableHttp.js");
+const server_js_1 = require("../server.js");
+/**
+ * Create an HTTP request handler for the MCP server.
+ *
+ * Each call to handleRequest creates new server and transport instances,
+ * providing complete isolation between requests. Callers should create
+ * a new handler when the config (API key/user ID) changes.
+ *
+ * @param config - MCP server configuration with API key and user ID
+ * @param options - Optional handler configuration
+ * @returns Object with handleRequest method for processing HTTP requests
+ *
+ * @example
+ * ```typescript
+ * // In a Fastify route handler
+ * const handler = createHttpHandler({
+ *   apiKey: 'sk_...',
+ *   userId: 'user-uuid',
+ *   baseUrl: 'https://api.attrove.com', // optional, SDK has its own default
+ * });
+ *
+ * // Handle POST request
+ * const result = await handler.handleRequest(req.raw, reply.raw, req.body);
+ * if (!result.handled) {
+ *   // No response sent - caller must send error response
+ *   res.status(500).json({ error: result.error });
+ * }
+ * ```
+ */
+/**
+ * Type guard for Node.js system errors with error codes.
+ */
+function isNodeError(error) {
+    return error instanceof Error && "code" in error;
+}
+function createHttpHandler(config, options = {}) {
+    const { enableJsonResponse = true, timeoutMs = 30000 } = options;
+    // Validate timeoutMs to prevent unexpected behavior
+    if (timeoutMs <= 0) {
+        throw new Error("timeoutMs must be a positive number");
+    }
+    return {
+        /**
+         * Handle an incoming HTTP request.
+         *
+         * @param req - Node.js IncomingMessage (or Fastify raw request)
+         * @param res - Node.js ServerResponse (or Fastify raw reply)
+         * @param parsedBody - Pre-parsed request body (optional, Fastify provides this)
+         * @returns Promise resolving to handler result indicating if request was processed
+         */
+        handleRequest: async (req, res, parsedBody) => {
+            let server;
+            let timeoutId;
+            let result;
+            let cleanupFailed = false;
+            let timeoutOccurred = false;
+            // Correlation ID links timeout errors with subsequent suppressed errors for debugging
+            const correlationId = (0, node_crypto_1.randomUUID)().slice(0, 8);
+            try {
+                server = (0, server_js_1.createServer)(config);
+                const transport = new streamableHttp_js_1.StreamableHTTPServerTransport({
+                    sessionIdGenerator: undefined, // Stateless mode - no session tracking needed
+                    enableJsonResponse,
+                });
+                await server.connect(transport);
+                const timeoutPromise = new Promise((_, reject) => {
+                    timeoutId = setTimeout(() => {
+                        timeoutOccurred = true;
+                        reject(new Error(`MCP request timed out after ${timeoutMs}ms`));
+                    }, timeoutMs);
+                });
+                // Store reference to transport promise so we can attach a catch handler.
+                // This prevents unhandled rejection if timeout wins the race and server.close()
+                // later causes the transport to reject.
+                const transportPromise = transport.handleRequest(req, res, parsedBody);
+                // When timeout occurs, Promise.race exits with the timeout error (caught below),
+                // but transportPromise may reject later when server.close() interrupts it.
+                // Only log here if a timeout actually occurred - otherwise Promise.race will
+                // propagate the rejection to the main catch block and logging here would be duplicate.
+                transportPromise.catch((suppressedError) => {
+                    if (!timeoutOccurred) {
+                        // No timeout - Promise.race will handle this rejection via the main catch block
+                        return;
+                    }
+                    const errorMsg = suppressedError instanceof Error
+                        ? suppressedError.message
+                        : String(suppressedError);
+                    // Critical errors that indicate systemic issues (not just slow requests)
+                    const isCritical = /SSL|certificate|ENOTFOUND|ECONNREFUSED|auth/i.test(errorMsg);
+                    const logData = {
+                        level: isCritical ? "error" : "warn",
+                        msg: "MCP transport rejected after timeout - suppressed to prevent unhandled rejection",
+                        errorId: isCritical
+                            ? "MCP_HTTP_SUPPRESSED_CRITICAL_ERROR"
+                            : "MCP_HTTP_SUPPRESSED_POST_TIMEOUT",
+                        correlationId,
+                        error: errorMsg,
+                        userId: config.userId,
+                    };
+                    // prettier-ignore
+                    console.error("[AttroveMCP]", JSON.stringify(logData));
+                });
+                await Promise.race([transportPromise, timeoutPromise]);
+                result = { handled: true };
+            }
+            catch (error) {
+                // Preserve context for non-Error values (e.g., throw "string", throw { code: ... })
+                const message = error instanceof Error
+                    ? error.message
+                    : typeof error === "object" && error !== null
+                        ? `Unknown error: ${JSON.stringify(error)}`
+                        : `Unknown error: ${String(error)}`;
+                const stack = error instanceof Error ? error.stack : undefined;
+                const isTimeout = error instanceof Error && error.message.includes("timed out");
+                // Classify error type for appropriate logging level
+                // Use error.code for socket errors (more precise than string matching)
+                const isSocketError = isNodeError(error) &&
+                    (error.code === "ECONNRESET" ||
+                        error.code === "EPIPE" ||
+                        error.code === "ECONNABORTED");
+                const isExpectedError = isTimeout || isSocketError;
+                // Log with structured JSON for observability (callers should also log via their infrastructure)
+                const errorId = isTimeout
+                    ? "MCP_HTTP_TIMEOUT"
+                    : isSocketError
+                        ? "MCP_HTTP_SOCKET_ERROR"
+                        : "MCP_HTTP_UNEXPECTED_ERROR";
+                const logData = {
+                    level: isExpectedError ? "warn" : "error",
+                    msg: isExpectedError
+                        ? "MCP HTTP handler operational failure"
+                        : "MCP HTTP handler unexpected failure",
+                    errorId,
+                    correlationId,
+                    error: message,
+                    isTimeout,
+                    userId: config.userId,
+                    ...(stack && !isExpectedError && { stack }),
+                    ...(!isExpectedError && { errorType: error?.constructor?.name }),
+                };
+                // prettier-ignore
+                console.error("[AttroveMCP]", JSON.stringify(logData));
+                result = { handled: false, error: message, stack, isTimeout };
+            }
+            finally {
+                // Clear timeout to prevent timer accumulation under load
+                if (timeoutId !== undefined) {
+                    clearTimeout(timeoutId);
+                }
+                if (server) {
+                    try {
+                        await server.close();
+                    }
+                    catch (cleanupError) {
+                        cleanupFailed = true;
+                        // Cleanup failures could indicate resource leaks - always log for monitoring
+                        const cleanupLogData = {
+                            level: "error",
+                            msg: "MCP server cleanup failed - potential resource leak",
+                            errorId: "MCP_CLEANUP_FAILURE",
+                            correlationId,
+                            error: cleanupError instanceof Error
+                                ? cleanupError.message
+                                : String(cleanupError),
+                            stack: cleanupError instanceof Error ? cleanupError.stack : undefined,
+                            userId: config.userId,
+                        };
+                        // prettier-ignore
+                        console.error("[AttroveMCP]", JSON.stringify(cleanupLogData));
+                    }
+                }
+            }
+            // Include cleanup failure warning in success result for monitoring
+            if (result.handled && cleanupFailed) {
+                return { handled: true, cleanupFailed: true };
+            }
+            return result;
+        },
+    };
+}
+exports.createHttpHandler = createHttpHandler;

package/esm/index.d.ts

@@ -28,6 +28,8 @@
  */
 export { createServer, startServer, getConfigFromEnv } from "./server.js";
 export type { McpServerConfig } from "./server.js";
-export { allToolDefinitions, queryToolDefinition, searchToolDefinition, integrationsToolDefinition, } from "./tools/index.js";
+export { allToolDefinitions, queryToolDefinition, searchToolDefinition, integrationsToolDefinition, eventsToolDefinition, meetingsToolDefinition, } from "./tools/index.js";
 export { getVersion } from "./version.js";
+export { createHttpHandler } from "./transport/http.js";
+export type { McpHttpHandler, McpHttpHandlerResult, McpHttpHandlerFailure, CreateHttpHandlerOptions, } from "./transport/http.js";
 //# sourceMappingURL=index.d.ts.map

package/esm/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/mcp/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC1E,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,GAC3B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../packages/mcp/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAC1E,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAEnD,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AACxD,YAAY,EACV,cAAc,EACd,oBAAoB,EACpB,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,qBAAqB,CAAC"}

package/esm/index.js

@@ -27,6 +27,8 @@
  * @packageDocumentation
  */
 export { createServer, startServer, getConfigFromEnv } from "./server.js";
-export { allToolDefinitions, queryToolDefinition, searchToolDefinition, integrationsToolDefinition, } from "./tools/index.js";
+export { allToolDefinitions, queryToolDefinition, searchToolDefinition, integrationsToolDefinition, eventsToolDefinition, meetingsToolDefinition, } from "./tools/index.js";
 export { getVersion } from "./version.js";
+// HTTP transport for hosted MCP endpoints
+export { createHttpHandler } from "./transport/http.js";
 //# sourceMappingURL=index.js.map

package/esm/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/mcp/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG1E,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,GAC3B,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../packages/mcp/src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAEH,OAAO,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AAG1E,OAAO,EACL,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,sBAAsB,GACvB,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAE1C,0CAA0C;AAC1C,OAAO,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC"}

package/esm/server.d.ts

@@ -5,35 +5,37 @@
  * to access user context through the Attrove API.
  */
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { ApiKeyFormat } from "@attrove/sdk";
 /**
  * Configuration for the MCP server.
  */
 export interface McpServerConfig {
     /**
      * Attrove API key (sk_ prefixed).
+     * Must be a valid ApiKeyFormat string starting with "sk_".
      */
-    apiKey: string;
+    apiKey: ApiKeyFormat;
     /**
      * User ID (UUID) to scope API calls.
      */
     userId: string;
     /**
-     * Optional API base URL.
+     * Optional API base URL. If not specified, the SDK's default is used.
      */
     baseUrl?: string;
 }
 /**
- * Create and configure the Attrove MCP server.
+ * Wire up tool definitions and dispatch logic for the Attrove MCP server.
  */
 export declare function createServer(config: McpServerConfig): Server;
 /**
- * Start the MCP server with stdio transport.
+ * Connect the MCP server to stdin/stdout and begin serving requests.
  */
 export declare function startServer(config: McpServerConfig): Promise<void>;
 /**
  * Get configuration from environment variables.
  *
- * @throws {Error} If required environment variables are missing
+ * @throws {Error} If required environment variables are missing or invalid
  */
 export declare function getConfigFromEnv(): McpServerConfig;
 //# sourceMappingURL=server.d.ts.map

package/esm/server.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../packages/mcp/src/server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAgEnE;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAiID;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAgH5D;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAIxE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,CAwBlD"}
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../../../packages/mcp/src/server.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAMnE,OAAO,EAKL,YAAY,EAEb,MAAM,cAAc,CAAC;AAuDtB;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,MAAM,EAAE,YAAY,CAAC;IAErB;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAgQD;;GAEG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,eAAe,GAAG,MAAM,CAgG5D;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,MAAM,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAIxE;AAED;;;;GAIG;AACH,wBAAgB,gBAAgB,IAAI,eAAe,CA8BlD"}