mcp-use 1.9.0 → 1.9.1-canary.1

package/dist/chunk-2EYAMIT3.js

@@ -0,0 +1,76 @@
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// src/server/prompts/conversion.ts
+function isGetPromptResult(result) {
+  return "messages" in result && Array.isArray(result.messages);
+}
+__name(isGetPromptResult, "isGetPromptResult");
+function convertToolResultToPromptResult(result) {
+  if (isGetPromptResult(result)) {
+    return result;
+  }
+  const messages = [];
+  if (result.content && result.content.length > 0) {
+    for (const content of result.content) {
+      if (content.type === "text") {
+        const textContent = content;
+        messages.push({
+          role: "user",
+          content: {
+            type: "text",
+            text: textContent.text
+          }
+        });
+      } else if (content.type === "image") {
+        const imageContent = content;
+        messages.push({
+          role: "user",
+          content: {
+            type: "image",
+            data: imageContent.data,
+            mimeType: imageContent.mimeType || "image/png"
+          }
+        });
+      } else if (content.type === "resource") {
+        const resourceContent = content;
+        const resourceData = resourceContent.resource;
+        const embeddedResource = {
+          type: "resource",
+          resource: {
+            uri: resourceData.uri,
+            mimeType: resourceData.mimeType
+          }
+        };
+        if (resourceData.text) {
+          embeddedResource.resource.text = resourceData.text;
+        } else if (resourceData.blob) {
+          embeddedResource.resource.blob = resourceData.blob;
+        }
+        messages.push({
+          role: "user",
+          content: embeddedResource
+        });
+      }
+    }
+  }
+  if (messages.length === 0) {
+    messages.push({
+      role: "user",
+      content: {
+        type: "text",
+        text: ""
+      }
+    });
+  }
+  return {
+    messages,
+    description: result._meta?.description
+  };
+}
+__name(convertToolResultToPromptResult, "convertToolResultToPromptResult");
+
+export {
+  convertToolResultToPromptResult
+};

package/dist/chunk-33U4IA4N.js

@@ -0,0 +1,337 @@
+import {
+  ElicitationValidationError
+} from "./chunk-KUEVOU4M.js";
+import {
+  generateUUID
+} from "./chunk-MTHLLDCX.js";
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// src/server/tools/tool-execution-helpers.ts
+import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
+function findSessionContext(sessions, initialRequestContext, extraProgressToken, extraSendNotification) {
+  let requestContext = initialRequestContext;
+  let session;
+  let progressToken = extraProgressToken;
+  let sendNotification = extraSendNotification;
+  if (!requestContext) {
+    for (const [, s] of sessions.entries()) {
+      if (s.context) {
+        requestContext = s.context;
+        break;
+      }
+    }
+  }
+  if (!progressToken || !sendNotification) {
+    if (requestContext) {
+      for (const [, s] of sessions.entries()) {
+        if (s.context === requestContext) {
+          session = s;
+          break;
+        }
+      }
+    } else {
+      const firstSession = sessions.values().next().value;
+      if (firstSession) {
+        session = firstSession;
+      }
+    }
+    if (session) {
+      if (!progressToken && session.progressToken) {
+        progressToken = session.progressToken;
+      }
+      if (!sendNotification && session.sendNotification) {
+        sendNotification = session.sendNotification;
+      }
+    }
+  }
+  return { requestContext, session, progressToken, sendNotification };
+}
+__name(findSessionContext, "findSessionContext");
+async function sendProgressNotification(sendNotification, progressToken, progress, total, message) {
+  if (sendNotification && progressToken !== void 0) {
+    try {
+      await sendNotification({
+        method: "notifications/progress",
+        params: {
+          progressToken,
+          progress,
+          total,
+          message
+        }
+      });
+    } catch {
+    }
+  }
+}
+__name(sendProgressNotification, "sendProgressNotification");
+async function withTimeout(promise, timeout, errorMessage) {
+  if (timeout && timeout !== Infinity) {
+    const timeoutPromise = new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(errorMessage)), timeout);
+    });
+    return await Promise.race([promise, timeoutPromise]);
+  }
+  return await promise;
+}
+__name(withTimeout, "withTimeout");
+function parseElicitParams(messageOrParams, schemaOrUrlOrOptions, maybeOptions) {
+  let sdkParams;
+  let zodSchema = null;
+  let options;
+  if (typeof messageOrParams === "string") {
+    const message = messageOrParams;
+    if (typeof schemaOrUrlOrOptions === "string") {
+      options = maybeOptions;
+      const elicitationId = `elicit-${generateUUID()}`;
+      sdkParams = {
+        mode: "url",
+        message,
+        url: schemaOrUrlOrOptions,
+        elicitationId
+      };
+    } else if (schemaOrUrlOrOptions && typeof schemaOrUrlOrOptions === "object" && "_def" in schemaOrUrlOrOptions) {
+      options = maybeOptions;
+      zodSchema = schemaOrUrlOrOptions;
+      const jsonSchema = toJsonSchemaCompat(schemaOrUrlOrOptions);
+      sdkParams = {
+        mode: "form",
+        message,
+        requestedSchema: jsonSchema
+      };
+    } else {
+      throw new Error(
+        "Invalid elicit signature: second parameter must be a Zod schema or URL string"
+      );
+    }
+  } else {
+    options = schemaOrUrlOrOptions;
+    const params = messageOrParams;
+    if (params.mode === "url") {
+      const elicitationId = `elicit-${generateUUID()}`;
+      sdkParams = {
+        mode: "url",
+        message: params.message,
+        url: params.url,
+        elicitationId
+      };
+    } else {
+      sdkParams = {
+        mode: "form",
+        message: params.message,
+        requestedSchema: params.requestedSchema
+      };
+    }
+  }
+  return { sdkParams, zodSchema, options };
+}
+__name(parseElicitParams, "parseElicitParams");
+function createSampleMethod(createMessage, progressToken, sendNotification) {
+  return async (promptOrParams, options) => {
+    let sampleParams;
+    if (typeof promptOrParams === "string") {
+      sampleParams = {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: promptOrParams
+            }
+          }
+        ],
+        maxTokens: options?.maxTokens || 1e3,
+        ...options?.modelPreferences && {
+          modelPreferences: options.modelPreferences
+        },
+        ...options?.systemPrompt && { systemPrompt: options.systemPrompt },
+        ...options?.temperature !== void 0 && {
+          temperature: options.temperature
+        },
+        ...options?.stopSequences && { stopSequences: options.stopSequences },
+        ...options?.metadata && { metadata: options.metadata }
+      };
+    } else {
+      sampleParams = promptOrParams;
+    }
+    const { timeout, progressIntervalMs = 5e3, onProgress } = options ?? {};
+    let progressCount = 0;
+    let completed = false;
+    let progressInterval = null;
+    if (progressToken !== void 0 && sendNotification) {
+      progressInterval = setInterval(async () => {
+        if (completed) return;
+        progressCount++;
+        const progressData = {
+          progress: progressCount,
+          total: void 0,
+          message: `Waiting for LLM response... (${progressCount * Math.round(progressIntervalMs / 1e3)}s elapsed)`
+        };
+        if (onProgress) {
+          try {
+            onProgress(progressData);
+          } catch {
+          }
+        }
+        await sendProgressNotification(
+          sendNotification,
+          progressToken,
+          progressData.progress,
+          progressData.total,
+          progressData.message
+        );
+      }, progressIntervalMs);
+    }
+    try {
+      console.log("[SAMPLING DEBUG] Calling createMessage...");
+      const sdkTimeout = timeout && timeout !== Infinity ? timeout : 2147483647;
+      const samplePromise = createMessage(sampleParams, {
+        timeout: sdkTimeout
+      });
+      console.log("[SAMPLING DEBUG] Waiting for response...");
+      const result = await withTimeout(
+        samplePromise,
+        timeout,
+        `Sampling timed out after ${timeout}ms`
+      );
+      console.log("[SAMPLING DEBUG] Got result:", result);
+      return result;
+    } catch (error) {
+      console.error("[SAMPLING DEBUG] Error during sampling:", error);
+      throw error;
+    } finally {
+      completed = true;
+      if (progressInterval) {
+        clearInterval(progressInterval);
+      }
+    }
+  };
+}
+__name(createSampleMethod, "createSampleMethod");
+function createElicitMethod(elicitInput) {
+  return async (messageOrParams, schemaOrUrlOrOptions, maybeOptions) => {
+    const { sdkParams, zodSchema, options } = parseElicitParams(
+      messageOrParams,
+      schemaOrUrlOrOptions,
+      maybeOptions
+    );
+    const { timeout } = options ?? {};
+    const sdkTimeout = timeout && timeout !== Infinity ? timeout : 2147483647;
+    const result = await elicitInput(sdkParams, { timeout: sdkTimeout });
+    if (zodSchema && result.action === "accept" && result.data) {
+      try {
+        const validatedData = zodSchema.parse(result.data);
+        return {
+          ...result,
+          data: validatedData
+        };
+      } catch (error) {
+        throw new ElicitationValidationError(
+          `Elicitation data validation failed: ${error.message}`,
+          error
+        );
+      }
+    }
+    return result;
+  };
+}
+__name(createElicitMethod, "createElicitMethod");
+function createReportProgressMethod(progressToken, sendNotification) {
+  if (progressToken !== void 0 && sendNotification) {
+    return async (progress, total, message) => {
+      await sendProgressNotification(
+        sendNotification,
+        progressToken,
+        progress,
+        total,
+        message
+      );
+    };
+  }
+  return void 0;
+}
+__name(createReportProgressMethod, "createReportProgressMethod");
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  notice: 2,
+  warning: 3,
+  error: 4,
+  critical: 5,
+  alert: 6,
+  emergency: 7
+};
+var VALID_LOG_LEVELS = [
+  "debug",
+  "info",
+  "notice",
+  "warning",
+  "error",
+  "critical",
+  "alert",
+  "emergency"
+];
+function isValidLogLevel(level) {
+  return VALID_LOG_LEVELS.includes(level);
+}
+__name(isValidLogLevel, "isValidLogLevel");
+function shouldLogMessage(messageLevel, minLevel) {
+  if (!minLevel) {
+    return true;
+  }
+  if (!isValidLogLevel(messageLevel) || !isValidLogLevel(minLevel)) {
+    return true;
+  }
+  return LOG_LEVELS[messageLevel] >= LOG_LEVELS[minLevel];
+}
+__name(shouldLogMessage, "shouldLogMessage");
+function createLogMethod(sendNotification, minLogLevel) {
+  if (!sendNotification) {
+    return void 0;
+  }
+  return async (level, message, logger) => {
+    if (!shouldLogMessage(level, minLogLevel)) {
+      return;
+    }
+    await sendNotification({
+      method: "notifications/message",
+      params: {
+        level,
+        data: message,
+        logger: logger || "tool"
+      }
+    });
+  };
+}
+__name(createLogMethod, "createLogMethod");
+function createEnhancedContext(baseContext, createMessage, elicitInput, progressToken, sendNotification, minLogLevel) {
+  const enhancedContext = baseContext ? Object.create(baseContext) : {};
+  enhancedContext.sample = createSampleMethod(
+    createMessage,
+    progressToken,
+    sendNotification
+  );
+  enhancedContext.elicit = createElicitMethod(elicitInput);
+  enhancedContext.reportProgress = createReportProgressMethod(
+    progressToken,
+    sendNotification
+  );
+  enhancedContext.log = createLogMethod(sendNotification, minLogLevel);
+  return enhancedContext;
+}
+__name(createEnhancedContext, "createEnhancedContext");
+
+export {
+  findSessionContext,
+  sendProgressNotification,
+  withTimeout,
+  parseElicitParams,
+  createSampleMethod,
+  createElicitMethod,
+  createReportProgressMethod,
+  VALID_LOG_LEVELS,
+  isValidLogLevel,
+  shouldLogMessage,
+  createEnhancedContext
+};

package/dist/chunk-362PI25Z.js

@@ -0,0 +1,110 @@
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// src/server/resources/conversion.ts
+function isReadResourceResult(result) {
+  return "contents" in result && Array.isArray(result.contents);
+}
+__name(isReadResourceResult, "isReadResourceResult");
+function extractMimeType(result) {
+  if (result._meta && typeof result._meta === "object") {
+    const meta = result._meta;
+    if (meta.mimeType && typeof meta.mimeType === "string") {
+      return meta.mimeType;
+    }
+  }
+  if (result.content && result.content.length > 0) {
+    const firstContent = result.content[0];
+    if (firstContent.type === "image") {
+      return firstContent.mimeType || "image/png";
+    }
+    if (firstContent.type === "text") {
+      return "text/plain";
+    }
+    if (firstContent.type === "resource") {
+      const resourceData = firstContent.resource;
+      return resourceData?.mimeType || "application/octet-stream";
+    }
+  }
+  return "text/plain";
+}
+__name(extractMimeType, "extractMimeType");
+function isBinaryContent(result) {
+  if (result._meta && typeof result._meta === "object") {
+    const meta = result._meta;
+    return meta.isBinary === true || meta.isImage === true;
+  }
+  return false;
+}
+__name(isBinaryContent, "isBinaryContent");
+function convertToolResultToResourceResult(uri, result) {
+  if (isReadResourceResult(result)) {
+    return result;
+  }
+  const mimeType = extractMimeType(result);
+  const isBinary = isBinaryContent(result);
+  const contents = [];
+  if (result.content && result.content.length > 0) {
+    for (const content of result.content) {
+      if (content.type === "text") {
+        const textContent = content;
+        if (isBinary) {
+          contents.push({
+            uri,
+            mimeType,
+            blob: textContent.text
+          });
+        } else {
+          contents.push({
+            uri,
+            mimeType,
+            text: textContent.text
+          });
+        }
+      } else if (content.type === "image") {
+        const imageContent = content;
+        contents.push({
+          uri,
+          mimeType: imageContent.mimeType || mimeType,
+          blob: imageContent.data
+        });
+      } else if (content.type === "resource") {
+        const resourceContent = content;
+        const resourceData = resourceContent.resource;
+        if (resourceData.text !== void 0) {
+          contents.push({
+            uri: resourceData.uri,
+            mimeType: resourceData.mimeType || mimeType,
+            text: resourceData.text
+          });
+        } else if (resourceData.blob !== void 0) {
+          contents.push({
+            uri: resourceData.uri,
+            mimeType: resourceData.mimeType || mimeType,
+            blob: resourceData.blob
+          });
+        } else {
+          contents.push({
+            uri: resourceData.uri,
+            mimeType: resourceData.mimeType || mimeType,
+            text: ""
+          });
+        }
+      }
+    }
+  }
+  if (contents.length === 0) {
+    contents.push({
+      uri,
+      mimeType: "text/plain",
+      text: ""
+    });
+  }
+  return { contents };
+}
+__name(convertToolResultToResourceResult, "convertToolResultToResourceResult");
+
+export {
+  convertToolResultToResourceResult
+};

package/dist/chunk-LWVK6RXA.js

@@ -0,0 +1,30 @@
+import {
+  __name
+} from "./chunk-3GQAWCBQ.js";
+
+// src/server/context-storage.ts
+import { AsyncLocalStorage } from "async_hooks";
+var requestContextStorage = new AsyncLocalStorage();
+async function runWithContext(context, fn, sessionId) {
+  return requestContextStorage.run({ honoContext: context, sessionId }, fn);
+}
+__name(runWithContext, "runWithContext");
+function getRequestContext() {
+  return requestContextStorage.getStore()?.honoContext;
+}
+__name(getRequestContext, "getRequestContext");
+function getSessionId() {
+  return requestContextStorage.getStore()?.sessionId;
+}
+__name(getSessionId, "getSessionId");
+function hasRequestContext() {
+  return requestContextStorage.getStore() !== void 0;
+}
+__name(hasRequestContext, "hasRequestContext");
+
+export {
+  runWithContext,
+  getRequestContext,
+  getSessionId,
+  hasRequestContext
+};

package/dist/context-storage-NA4MHWOZ.js

@@ -0,0 +1,13 @@
+import {
+  getRequestContext,
+  getSessionId,
+  hasRequestContext,
+  runWithContext
+} from "./chunk-LWVK6RXA.js";
+import "./chunk-3GQAWCBQ.js";
+export {
+  getRequestContext,
+  getSessionId,
+  hasRequestContext,
+  runWithContext
+};

package/dist/conversion-5MA4VY3B.js

@@ -0,0 +1,7 @@
+import {
+  convertToolResultToResourceResult
+} from "./chunk-362PI25Z.js";
+import "./chunk-3GQAWCBQ.js";
+export {
+  convertToolResultToResourceResult
+};

package/dist/conversion-OTRZZBUU.js

@@ -0,0 +1,7 @@
+import {
+  convertToolResultToPromptResult
+} from "./chunk-2EYAMIT3.js";
+import "./chunk-3GQAWCBQ.js";
+export {
+  convertToolResultToPromptResult
+};

package/dist/src/server/context-storage.d.ts

@@ -15,6 +15,7 @@ import type { Context } from "hono";
  *
  * @param context - Hono Context object to store
  * @param fn - Function to execute within this context
+ * @param sessionId - Optional session ID to store with the context
  * @returns Promise resolving to the function's return value
  *
  * @example
@@ -28,7 +29,7 @@ import type { Context } from "hono";
  * });
  * ```
  */
-export declare function runWithContext<T>(context: Context, fn: () => Promise<T>): Promise<T>;
+export declare function runWithContext<T>(context: Context, fn: () => Promise<T>, sessionId?: string): Promise<T>;
 /**
  * Get the current request context from AsyncLocalStorage
  *
@@ -45,6 +46,12 @@ export declare function runWithContext<T>(context: Context, fn: () => Promise<T>
  * ```
  */
 export declare function getRequestContext(): Context | undefined;
+/**
+ * Get the current session ID from AsyncLocalStorage
+ *
+ * @returns The session ID for the current async operation, or undefined if not in a request context
+ */
+export declare function getSessionId(): string | undefined;
 /**
  * Check if currently executing within a request context
  *

package/dist/src/server/context-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"context-storage.d.ts","sourceRoot":"","sources":["../../../src/server/context-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAQpC;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,cAAc,CAAC,CAAC,EACpC,OAAO,EAAE,OAAO,EAChB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GACnB,OAAO,CAAC,CAAC,CAAC,CAEZ;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,GAAG,SAAS,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C"}
+{"version":3,"file":"context-storage.d.ts","sourceRoot":"","sources":["../../../src/server/context-storage.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AAgBpC;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,cAAc,CAAC,CAAC,EACpC,OAAO,EAAE,OAAO,EAChB,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EACpB,SAAS,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,CAAC,CAAC,CAEZ;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,GAAG,SAAS,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,IAAI,MAAM,GAAG,SAAS,CAEjD;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,IAAI,OAAO,CAE3C"}

package/dist/src/server/endpoints/index.d.ts

@@ -0,0 +1,7 @@
+/**
+ * MCP Endpoints Module
+ *
+ * Exports endpoint mounting function.
+ */
+export { mountMcp } from "./mount-mcp.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/src/server/endpoints/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/endpoints/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/src/server/endpoints/mount-mcp.d.ts

@@ -0,0 +1,21 @@
+/**
+ * MCP Endpoint Mounting
+ *
+ * Main orchestration function for mounting MCP endpoints at /mcp and /sse.
+ * Uses a single native SDK transport instance to handle all sessions.
+ */
+import type { Hono as HonoType } from "hono";
+import type { SessionData } from "../sessions/index.js";
+import type { ServerConfig } from "../types/index.js";
+/**
+ * Mount MCP server endpoints at /mcp and /sse
+ *
+ * Uses FetchStreamableHTTPServerTransport (Web Standard APIs) for proper bidirectional communication.
+ * Follows the official Hono example from PR #1209.
+ */
+export declare function mountMcp(app: HonoType, mcpServerInstance: any, // The McpServer instance with getServerForSession() method
+sessions: Map<string, SessionData>, config: ServerConfig, isProductionMode: boolean): Promise<{
+    mcpMounted: boolean;
+    idleCleanupInterval?: NodeJS.Timeout;
+}>;
+//# sourceMappingURL=mount-mcp.d.ts.map

package/dist/src/server/endpoints/mount-mcp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mount-mcp.d.ts","sourceRoot":"","sources":["../../../../src/server/endpoints/mount-mcp.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAW,IAAI,IAAI,QAAQ,EAAE,MAAM,MAAM,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AAExD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGtD;;;;;GAKG;AACH,wBAAsB,QAAQ,CAC5B,GAAG,EAAE,QAAQ,EACb,iBAAiB,EAAE,GAAG,EAAE,2DAA2D;AACnF,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,WAAW,CAAC,EAClC,MAAM,EAAE,YAAY,EACpB,gBAAgB,EAAE,OAAO,GACxB,OAAO,CAAC;IAAE,UAAU,EAAE,OAAO,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,CAAC,OAAO,CAAA;CAAE,CAAC,CAkFxE"}