mcp-use 1.34.2 → 1.34.3

package/dist/chunk-SUVUANZ3.js

@@ -0,0 +1,594 @@
+import {
+  getRequestContext
+} from "./chunk-G7JEMXJW.js";
+import {
+  ElicitationValidationError
+} from "./chunk-KUEVOU4M.js";
+import {
+  Telemetry
+} from "./chunk-BJIP3NFE.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 extractContextData(honoCtx) {
+  const data = {};
+  try {
+    const varObj = honoCtx.var;
+    if (varObj && typeof varObj === "object") {
+      for (const [key, value] of Object.entries(varObj)) {
+        data[key] = value;
+      }
+    }
+  } catch {
+  }
+  try {
+    const auth = honoCtx.get("auth");
+    if (auth) data.auth = auth;
+  } catch {
+  }
+  try {
+    data.req = honoCtx.req;
+  } catch {
+  }
+  try {
+    data.env = honoCtx.env;
+  } catch {
+  }
+  data.get = (key) => data[key];
+  data.set = (key, value) => {
+    data[key] = value;
+  };
+  return data;
+}
+__name(extractContextData, "extractContextData");
+function normalizeUserContext(rawMeta) {
+  if (!rawMeta) return void 0;
+  const userAgent = rawMeta["openai/userAgent"];
+  const locale = rawMeta["openai/locale"];
+  const rawLocation = rawMeta["openai/userLocation"];
+  const timezoneOffsetMinutes = typeof rawMeta["timezone_offset_minutes"] === "number" ? rawMeta["timezone_offset_minutes"] : void 0;
+  const subject = rawMeta["openai/subject"];
+  const conversationId = rawMeta["openai/session"];
+  const location = rawLocation ? {
+    city: rawLocation.city,
+    region: rawLocation.region,
+    country: rawLocation.country,
+    timezone: rawLocation.timezone,
+    latitude: rawLocation.latitude,
+    longitude: rawLocation.longitude
+  } : void 0;
+  const hasAnyField = userAgent !== void 0 || locale !== void 0 || location !== void 0 || timezoneOffsetMinutes !== void 0 || subject !== void 0 || conversationId !== void 0;
+  if (!hasAnyField) return void 0;
+  return {
+    ...userAgent !== void 0 && { userAgent },
+    ...locale !== void 0 && { locale },
+    ...location !== void 0 && { location },
+    ...timezoneOffsetMinutes !== void 0 && { timezoneOffsetMinutes },
+    ...subject !== void 0 && { subject },
+    ...conversationId !== void 0 && { conversationId }
+  };
+}
+__name(normalizeUserContext, "normalizeUserContext");
+function findSessionContext(sessions, initialRequestContext, extraProgressToken, extraSendNotification) {
+  const requestContext = initialRequestContext;
+  let session;
+  let progressToken = extraProgressToken;
+  let sendNotification = extraSendNotification;
+  if (requestContext) {
+    for (const [, s] of sessions.entries()) {
+      if (s.context === requestContext) {
+        session = s;
+        break;
+      }
+    }
+  }
+  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);
+      Telemetry.getInstance().trackServerContext({
+        contextType: "sample"
+      }).catch((e) => console.debug(`Failed to track sample context: ${e}`));
+      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 });
+    Telemetry.getInstance().trackServerContext({
+      contextType: "elicit"
+    }).catch((e) => console.debug(`Failed to track elicit context: ${e}`));
+    const inputData = result.data ?? result.content;
+    if (zodSchema && result.action === "accept" && inputData) {
+      try {
+        const validatedData = zodSchema.parse(inputData);
+        return {
+          ...result,
+          data: validatedData
+        };
+      } catch (error) {
+        const err = error;
+        throw new ElicitationValidationError(
+          `Elicitation data validation failed: ${err.message}`,
+          err
+        );
+      }
+    }
+    if (!zodSchema && result.action === "accept" && inputData) {
+      return {
+        ...result,
+        data: inputData
+      };
+    }
+    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"
+      }
+    });
+    Telemetry.getInstance().trackServerContext({
+      contextType: "notification",
+      notificationType: "message"
+    }).catch(
+      (e) => console.debug(`Failed to track notification context: ${e}`)
+    );
+  };
+}
+__name(createLogMethod, "createLogMethod");
+var MCP_UI_EXTENSION_ID = "io.modelcontextprotocol/ui";
+var MCP_UI_MIME_TYPE = "text/html;profile=mcp-app";
+function supportsApps(clientCapabilities) {
+  return clientCapabilities?.extensions?.[MCP_UI_EXTENSION_ID]?.mimeTypes?.includes(MCP_UI_MIME_TYPE) ?? false;
+}
+__name(supportsApps, "supportsApps");
+function createClientCapabilityChecker(clientCapabilities, clientInfo, requestMeta) {
+  const caps = clientCapabilities || {};
+  return {
+    can(capability) {
+      return capability in caps;
+    },
+    capabilities() {
+      return { ...caps };
+    },
+    /**
+     * Returns the name and version of the connecting client as advertised
+     * in the MCP initialize handshake.
+     */
+    info() {
+      return { ...clientInfo };
+    },
+    /**
+     * Returns the settings object for a specific extension (SEP-1724).
+     * Returns `undefined` if the client did not advertise that extension.
+     *
+     * @example
+     * ```typescript
+     * // Check for MCP Apps support (SEP-1865)
+     * const uiExt = ctx.client.extension("io.modelcontextprotocol/ui");
+     * if (uiExt?.mimeTypes?.includes("text/html;profile=mcp-app")) { ... }
+     *
+     * // Or use the convenience method:
+     * if (ctx.client.supportsApps()) { ... }
+     * ```
+     */
+    extension(id) {
+      return caps?.extensions?.[id];
+    },
+    /**
+     * Returns `true` if the client advertises support for MCP Apps
+     * (SEP-1865, extension identifier `io.modelcontextprotocol/ui`).
+     *
+     * Use this to conditionally register widget-enabled tool variants
+     * or return widget-aware responses.
+     *
+     * @example
+     * ```typescript
+     * if (ctx.client.supportsApps()) {
+     *   return widget({ uri: "ui://my-widget", props: result });
+     * }
+     * return text(result.summary);
+     * ```
+     */
+    supportsApps() {
+      return supportsApps(caps);
+    },
+    /**
+     * Returns normalized end-user context from `params._meta` sent by the
+     * client on this specific tool invocation.
+     *
+     * **Scope:** Per-invocation — unlike other `ctx.client` methods which
+     * are stable for the lifetime of the MCP session, `user()` can return
+     * a different value on every tool call.
+     *
+     * **Returns `undefined`** when the client does not include user metadata
+     * (e.g. Inspector, Claude Desktop, CLI, most non-ChatGPT clients).
+     *
+     * **Advisory only:** This data is self-reported by the client and
+     * unverified. For verified identity use `ctx.auth` (requires OAuth).
+     *
+     * **ChatGPT multi-tenant model:**
+     * ChatGPT uses a single MCP session for all users of your app. Use
+     * `subject` to identify the human and `conversationId` to identify the
+     * chat thread — both vary per invocation within the same MCP session:
+     *
+     * ```
+     * 1 MCP session  (ctx.session.sessionId)        — shared across all users
+     *   N subjects   (ctx.client.user()?.subject)   — one per ChatGPT user
+     *     M threads  (ctx.client.user()?.conversationId) — one per chat
+     * ```
+     *
+     * @example
+     * ```typescript
+     * server.tool({ name: "greet", schema: z.object({}) }, async (_p, ctx) => {
+     *   const caller = ctx.client.user();
+     *   if (caller) {
+     *     // Personalise by locale or location
+     *     const greeting = caller.locale?.startsWith("it") ? "Ciao" : "Hello";
+     *     const city = caller.location?.city ?? "there";
+     *     return text(`${greeting} from ${city}!`);
+     *   }
+     *   return text("Hello!");
+     * });
+     * ```
+     */
+    user() {
+      return normalizeUserContext(requestMeta);
+    }
+  };
+}
+__name(createClientCapabilityChecker, "createClientCapabilityChecker");
+function createSendNotificationMethod(sessionId, sessions) {
+  if (!sessionId || !sessions) {
+    return void 0;
+  }
+  return async (method, params) => {
+    const session = sessions.get(sessionId);
+    if (!session?.sendNotification) {
+      console.warn(
+        `[MCP] Cannot send notification to session ${sessionId} - no sendNotification function`
+      );
+      return;
+    }
+    try {
+      await session.sendNotification({
+        method,
+        params: params || {}
+      });
+    } catch (error) {
+      console.error(
+        `[MCP] Error sending notification to session ${sessionId}:`,
+        error
+      );
+    }
+  };
+}
+__name(createSendNotificationMethod, "createSendNotificationMethod");
+function createSendNotificationToSessionMethod(sessions) {
+  if (!sessions) {
+    return void 0;
+  }
+  return async (sessionId, method, params) => {
+    const session = sessions.get(sessionId);
+    if (!session?.sendNotification) {
+      return false;
+    }
+    try {
+      await session.sendNotification({
+        method,
+        params: params || {}
+      });
+      return true;
+    } catch (error) {
+      console.error(
+        `[MCP] Error sending notification to session ${sessionId}:`,
+        error
+      );
+      return false;
+    }
+  };
+}
+__name(createSendNotificationToSessionMethod, "createSendNotificationToSessionMethod");
+function createEnhancedContext(baseContext, createMessage, elicitInput, progressToken, sendNotification, minLogLevel, clientCapabilities, sessionId, sessions, clientInfo, requestMeta) {
+  const enhancedContext = baseContext ? extractContextData(baseContext) : {};
+  enhancedContext.sample = createSampleMethod(
+    createMessage,
+    progressToken,
+    sendNotification
+  );
+  enhancedContext.elicit = createElicitMethod(elicitInput);
+  enhancedContext.reportProgress = createReportProgressMethod(
+    progressToken,
+    sendNotification
+  );
+  enhancedContext.log = createLogMethod(sendNotification, minLogLevel);
+  enhancedContext.client = createClientCapabilityChecker(
+    clientCapabilities,
+    clientInfo,
+    requestMeta
+  );
+  if (sessionId) {
+    enhancedContext.session = {
+      sessionId
+    };
+  }
+  const sendNotificationMethod = createSendNotificationMethod(
+    sessionId,
+    sessions
+  );
+  if (sendNotificationMethod) {
+    enhancedContext.sendNotification = sendNotificationMethod;
+  }
+  const sendNotificationToSessionMethod = createSendNotificationToSessionMethod(sessions);
+  if (sendNotificationToSessionMethod) {
+    enhancedContext.sendNotificationToSession = sendNotificationToSessionMethod;
+  }
+  return enhancedContext;
+}
+__name(createEnhancedContext, "createEnhancedContext");
+function buildHandlerContext(sessionId, sessions) {
+  const session = sessionId ? sessions.get(sessionId) : void 0;
+  const requestContext = getRequestContext() || session?.context;
+  const enhancedCtx = requestContext ? extractContextData(requestContext) : {};
+  Object.defineProperty(enhancedCtx, "client", {
+    value: createClientCapabilityChecker(
+      session?.clientCapabilities,
+      session?.clientInfo
+    ),
+    writable: true,
+    enumerable: true,
+    configurable: true
+  });
+  return { session, enhancedCtx };
+}
+__name(buildHandlerContext, "buildHandlerContext");
+
+export {
+  findSessionContext,
+  createSampleMethod,
+  createElicitMethod,
+  isValidLogLevel,
+  supportsApps,
+  createClientCapabilityChecker,
+  createEnhancedContext,
+  buildHandlerContext
+};