mcp-use 1.6.3-canary.0 → 1.7.0-canary.2

package/dist/{chunk-BWOTID2D.js → chunk-AGKMD2ZM.js}

@@ -1,3 +1,6 @@
+import {
+  generateUUID
+} from "./chunk-MTHLLDCX.js";
 import {
   BaseConnector
 } from "./chunk-2JBWOW4S.js";
@@ -428,6 +431,7 @@ var HttpConnector = class extends BaseConnector {
         stop: /* @__PURE__ */ __name(async () => {
           if (this.streamableTransport) {
             try {
+              await this.streamableTransport.terminateSession();
               await this.streamableTransport.close();
             } catch (e) {
               logger.warn(`Error closing Streamable HTTP transport: ${e}`);
@@ -452,6 +456,8 @@ var HttpConnector = class extends BaseConnector {
   async connectWithSse(baseUrl) {
     try {
       this.connectionManager = new SseConnectionManager(baseUrl, {
+        authProvider: this.opts.authProvider,
+        // ← Pass OAuth provider to SDK (same as streamable HTTP)
         requestInit: {
           headers: this.headers
         }
@@ -506,9 +512,6 @@ var HttpConnector = class extends BaseConnector {
   }
 };
 
-// src/connectors/websocket.ts
-import { v4 as uuidv4 } from "uuid";
-
 // src/task_managers/websocket.ts
 import WS from "ws";
 var WebSocketConnectionManager = class extends ConnectionManager {
@@ -627,7 +630,7 @@ var WebSocketConnector = class extends BaseConnector {
   }
   sendRequest(method, params = null) {
     if (!this.ws) throw new Error("WebSocket is not connected");
-    const id = uuidv4();
+    const id = generateUUID();
     const payload = JSON.stringify({ id, method, params: params ?? {} });
     return new Promise((resolve, reject) => {
       this.pending.set(id, { resolve, reject });
@@ -782,350 +785,6 @@ var WebSocketConnector = class extends BaseConnector {
   }
 };
 
-// src/auth/browser-provider.ts
-import { sanitizeUrl } from "strict-url-sanitise";
-var BrowserOAuthClientProvider = class {
-  static {
-    __name(this, "BrowserOAuthClientProvider");
-  }
-  serverUrl;
-  storageKeyPrefix;
-  serverUrlHash;
-  clientName;
-  clientUri;
-  callbackUrl;
-  preventAutoAuth;
-  onPopupWindow;
-  constructor(serverUrl, options = {}) {
-    this.serverUrl = serverUrl;
-    this.storageKeyPrefix = options.storageKeyPrefix || "mcp:auth";
-    this.serverUrlHash = this.hashString(serverUrl);
-    this.clientName = options.clientName || "mcp-use";
-    this.clientUri = options.clientUri || (typeof window !== "undefined" ? window.location.origin : "");
-    this.callbackUrl = sanitizeUrl(
-      options.callbackUrl || (typeof window !== "undefined" ? new URL("/oauth/callback", window.location.origin).toString() : "/oauth/callback")
-    );
-    this.preventAutoAuth = options.preventAutoAuth;
-    this.onPopupWindow = options.onPopupWindow;
-  }
-  // --- SDK Interface Methods ---
-  get redirectUrl() {
-    return sanitizeUrl(this.callbackUrl);
-  }
-  get clientMetadata() {
-    return {
-      redirect_uris: [this.redirectUrl],
-      token_endpoint_auth_method: "none",
-      // Public client
-      grant_types: ["authorization_code", "refresh_token"],
-      response_types: ["code"],
-      client_name: this.clientName,
-      client_uri: this.clientUri
-      // scope: 'openid profile email mcp', // Example scopes, adjust as needed
-    };
-  }
-  async clientInformation() {
-    const key = this.getKey("client_info");
-    const data = localStorage.getItem(key);
-    if (!data) return void 0;
-    try {
-      return JSON.parse(data);
-    } catch (e) {
-      console.warn(
-        `[${this.storageKeyPrefix}] Failed to parse client information:`,
-        e
-      );
-      localStorage.removeItem(key);
-      return void 0;
-    }
-  }
-  // NOTE: The SDK's auth() function uses this if dynamic registration is needed.
-  // Ensure your OAuthClientInformationFull matches the expected structure if DCR is used.
-  async saveClientInformation(clientInformation) {
-    const key = this.getKey("client_info");
-    localStorage.setItem(key, JSON.stringify(clientInformation));
-  }
-  async tokens() {
-    const key = this.getKey("tokens");
-    const data = localStorage.getItem(key);
-    if (!data) return void 0;
-    try {
-      return JSON.parse(data);
-    } catch (e) {
-      console.warn(`[${this.storageKeyPrefix}] Failed to parse tokens:`, e);
-      localStorage.removeItem(key);
-      return void 0;
-    }
-  }
-  async saveTokens(tokens) {
-    const key = this.getKey("tokens");
-    localStorage.setItem(key, JSON.stringify(tokens));
-    localStorage.removeItem(this.getKey("code_verifier"));
-    localStorage.removeItem(this.getKey("last_auth_url"));
-  }
-  async saveCodeVerifier(codeVerifier) {
-    const key = this.getKey("code_verifier");
-    localStorage.setItem(key, codeVerifier);
-  }
-  async codeVerifier() {
-    const key = this.getKey("code_verifier");
-    const verifier = localStorage.getItem(key);
-    if (!verifier) {
-      throw new Error(
-        `[${this.storageKeyPrefix}] Code verifier not found in storage for key ${key}. Auth flow likely corrupted or timed out.`
-      );
-    }
-    return verifier;
-  }
-  /**
-   * Generates and stores the authorization URL with state, without opening a popup.
-   * Used when preventAutoAuth is enabled to provide the URL for manual navigation.
-   * @param authorizationUrl The fully constructed authorization URL from the SDK.
-   * @returns The full authorization URL with state parameter.
-   */
-  async prepareAuthorizationUrl(authorizationUrl) {
-    const state = globalThis.crypto.randomUUID();
-    const stateKey = `${this.storageKeyPrefix}:state_${state}`;
-    const stateData = {
-      serverUrlHash: this.serverUrlHash,
-      expiry: Date.now() + 1e3 * 60 * 10,
-      // State expires in 10 minutes
-      // Store provider options needed to reconstruct on callback
-      providerOptions: {
-        serverUrl: this.serverUrl,
-        storageKeyPrefix: this.storageKeyPrefix,
-        clientName: this.clientName,
-        clientUri: this.clientUri,
-        callbackUrl: this.callbackUrl
-      }
-    };
-    localStorage.setItem(stateKey, JSON.stringify(stateData));
-    authorizationUrl.searchParams.set("state", state);
-    const authUrlString = authorizationUrl.toString();
-    const sanitizedAuthUrl = sanitizeUrl(authUrlString);
-    localStorage.setItem(this.getKey("last_auth_url"), sanitizedAuthUrl);
-    return sanitizedAuthUrl;
-  }
-  /**
-   * Redirects the user agent to the authorization URL, storing necessary state.
-   * This now adheres to the SDK's void return type expectation for the interface.
-   * @param authorizationUrl The fully constructed authorization URL from the SDK.
-   */
-  async redirectToAuthorization(authorizationUrl) {
-    if (this.preventAutoAuth) return;
-    const sanitizedAuthUrl = await this.prepareAuthorizationUrl(authorizationUrl);
-    const popupFeatures = "width=600,height=700,resizable=yes,scrollbars=yes,status=yes";
-    try {
-      const popup = window.open(
-        sanitizedAuthUrl,
-        `mcp_auth_${this.serverUrlHash}`,
-        popupFeatures
-      );
-      if (this.onPopupWindow) {
-        this.onPopupWindow(sanitizedAuthUrl, popupFeatures, popup);
-      }
-      if (!popup || popup.closed || typeof popup.closed === "undefined") {
-        console.warn(
-          `[${this.storageKeyPrefix}] Popup likely blocked by browser. Manual navigation might be required using the stored URL.`
-        );
-      } else {
-        popup.focus();
-        console.info(
-          `[${this.storageKeyPrefix}] Redirecting to authorization URL in popup.`
-        );
-      }
-    } catch (e) {
-      console.error(
-        `[${this.storageKeyPrefix}] Error opening popup window:`,
-        e
-      );
-    }
-  }
-  // --- Helper Methods ---
-  /**
-   * Retrieves the last URL passed to `redirectToAuthorization`. Useful for manual fallback.
-   */
-  getLastAttemptedAuthUrl() {
-    const storedUrl = localStorage.getItem(this.getKey("last_auth_url"));
-    return storedUrl ? sanitizeUrl(storedUrl) : null;
-  }
-  clearStorage() {
-    const prefixPattern = `${this.storageKeyPrefix}_${this.serverUrlHash}_`;
-    const statePattern = `${this.storageKeyPrefix}:state_`;
-    const keysToRemove = [];
-    let count = 0;
-    for (let i = 0; i < localStorage.length; i++) {
-      const key = localStorage.key(i);
-      if (!key) continue;
-      if (key.startsWith(prefixPattern)) {
-        keysToRemove.push(key);
-      } else if (key.startsWith(statePattern)) {
-        try {
-          const item = localStorage.getItem(key);
-          if (item) {
-            const state = JSON.parse(item);
-            if (state.serverUrlHash === this.serverUrlHash) {
-              keysToRemove.push(key);
-            }
-          }
-        } catch (e) {
-          console.warn(
-            `[${this.storageKeyPrefix}] Error parsing state key ${key} during clearStorage:`,
-            e
-          );
-        }
-      }
-    }
-    const uniqueKeysToRemove = [...new Set(keysToRemove)];
-    uniqueKeysToRemove.forEach((key) => {
-      localStorage.removeItem(key);
-      count++;
-    });
-    return count;
-  }
-  hashString(str) {
-    let hash = 0;
-    for (let i = 0; i < str.length; i++) {
-      const char = str.charCodeAt(i);
-      hash = (hash << 5) - hash + char;
-      hash = hash & hash;
-    }
-    return Math.abs(hash).toString(16);
-  }
-  getKey(keySuffix) {
-    return `${this.storageKeyPrefix}_${this.serverUrlHash}_${keySuffix}`;
-  }
-};
-
-// src/auth/callback.ts
-import { auth } from "@modelcontextprotocol/sdk/client/auth.js";
-async function onMcpAuthorization() {
-  const queryParams = new URLSearchParams(window.location.search);
-  const code = queryParams.get("code");
-  const state = queryParams.get("state");
-  const error = queryParams.get("error");
-  const errorDescription = queryParams.get("error_description");
-  const logPrefix = "[mcp-callback]";
-  console.log(`${logPrefix} Handling callback...`, {
-    code,
-    state,
-    error,
-    errorDescription
-  });
-  let provider = null;
-  let storedStateData = null;
-  const stateKey = state ? `mcp:auth:state_${state}` : null;
-  try {
-    if (error) {
-      throw new Error(
-        `OAuth error: ${error} - ${errorDescription || "No description provided."}`
-      );
-    }
-    if (!code) {
-      throw new Error(
-        "Authorization code not found in callback query parameters."
-      );
-    }
-    if (!state || !stateKey) {
-      throw new Error(
-        "State parameter not found or invalid in callback query parameters."
-      );
-    }
-    const storedStateJSON = localStorage.getItem(stateKey);
-    if (!storedStateJSON) {
-      throw new Error(
-        `Invalid or expired state parameter "${state}". No matching state found in storage.`
-      );
-    }
-    try {
-      storedStateData = JSON.parse(storedStateJSON);
-    } catch (e) {
-      throw new Error("Failed to parse stored OAuth state.");
-    }
-    if (!storedStateData.expiry || storedStateData.expiry < Date.now()) {
-      localStorage.removeItem(stateKey);
-      throw new Error(
-        "OAuth state has expired. Please try initiating authentication again."
-      );
-    }
-    if (!storedStateData.providerOptions) {
-      throw new Error("Stored state is missing required provider options.");
-    }
-    const { serverUrl, ...providerOptions } = storedStateData.providerOptions;
-    console.log(
-      `${logPrefix} Re-instantiating provider for server: ${serverUrl}`
-    );
-    provider = new BrowserOAuthClientProvider(serverUrl, providerOptions);
-    console.log(`${logPrefix} Calling SDK auth() to exchange code...`);
-    const baseUrl = new URL(serverUrl).origin;
-    const authResult = await auth(provider, {
-      serverUrl: baseUrl,
-      authorizationCode: code
-    });
-    if (authResult === "AUTHORIZED") {
-      console.log(
-        `${logPrefix} Authorization successful via SDK auth(). Notifying opener...`
-      );
-      if (window.opener && !window.opener.closed) {
-        window.opener.postMessage(
-          { type: "mcp_auth_callback", success: true },
-          window.location.origin
-        );
-        window.close();
-      } else {
-        console.warn(
-          `${logPrefix} No opener window detected. Redirecting to root.`
-        );
-        const pathParts = window.location.pathname.split("/").filter(Boolean);
-        const basePath = pathParts.length > 0 && pathParts[pathParts.length - 1] === "callback" ? "/" + pathParts.slice(0, -2).join("/") : "/";
-        window.location.href = basePath || "/";
-      }
-      localStorage.removeItem(stateKey);
-    } else {
-      console.warn(
-        `${logPrefix} SDK auth() returned unexpected status: ${authResult}`
-      );
-      throw new Error(
-        `Unexpected result from authentication library: ${authResult}`
-      );
-    }
-  } catch (err) {
-    console.error(`${logPrefix} Error during OAuth callback handling:`, err);
-    const errorMessage = err instanceof Error ? err.message : String(err);
-    if (window.opener && !window.opener.closed) {
-      window.opener.postMessage(
-        { type: "mcp_auth_callback", success: false, error: errorMessage },
-        window.location.origin
-      );
-    }
-    try {
-      document.body.innerHTML = `
-            <div style="font-family: sans-serif; padding: 20px;">
-            <h1>Authentication Error</h1>
-            <p style="color: red; background-color: #ffebeb; border: 1px solid red; padding: 10px; border-radius: 4px;">
-                ${errorMessage}
-            </p>
-            <p>You can close this window or <a href="#" onclick="window.close(); return false;">click here to close</a>.</p>
-            <pre style="font-size: 0.8em; color: #555; margin-top: 20px; white-space: pre-wrap;">${err instanceof Error ? err.stack : ""}</pre>
-            </div>
-        `;
-    } catch (displayError) {
-      console.error(
-        `${logPrefix} Could not display error in callback window:`,
-        displayError
-      );
-    }
-    if (stateKey) {
-      localStorage.removeItem(stateKey);
-    }
-    if (provider) {
-      localStorage.removeItem(provider.getKey("code_verifier"));
-      localStorage.removeItem(provider.getKey("last_auth_url"));
-    }
-  }
-}
-__name(onMcpAuthorization, "onMcpAuthorization");
-
 // src/client/base.ts
 var BaseMCPClient = class {
   static {
@@ -1310,7 +969,5 @@ export {
   ConnectionManager,
   HttpConnector,
   WebSocketConnector,
-  BrowserOAuthClientProvider,
-  onMcpAuthorization,
   BrowserMCPClient
 };

package/dist/{chunk-SJEHVCPM.js → chunk-BG2APH43.js}

@@ -1,14 +1,16 @@
 import {
-  BrowserMCPClient,
-  BrowserOAuthClientProvider
-} from "./chunk-BWOTID2D.js";
+  BrowserMCPClient
+} from "./chunk-AGKMD2ZM.js";
+import {
+  BrowserOAuthClientProvider,
+  sanitizeUrl
+} from "./chunk-3R5PDYIN.js";
 import {
   __name
 } from "./chunk-3GQAWCBQ.js";
 
 // src/react/useMcp.ts
 import { useCallback, useEffect, useRef, useState } from "react";
-import { sanitizeUrl } from "strict-url-sanitise";
 
 // src/utils/assert.ts
 function assert(condition, message) {
@@ -21,7 +23,6 @@ __name(assert, "assert");
 // src/react/useMcp.ts
 var DEFAULT_RECONNECT_DELAY = 3e3;
 var DEFAULT_RETRY_DELAY = 5e3;
-var AUTH_TIMEOUT = 5 * 60 * 1e3;
 function useMcp(options) {
   const {
     url,
@@ -39,6 +40,9 @@ function useMcp(options) {
     autoReconnect = DEFAULT_RECONNECT_DELAY,
     transportType = "auto",
     preventAutoAuth = false,
+    // Default to false for backward compatibility (auto-trigger OAuth)
+    useRedirectFlow = false,
+    // Default to false for backward compatibility (use popup)
     onPopupWindow,
     timeout = 3e4,
     // 30 seconds default for connection timeout
@@ -164,6 +168,7 @@ function useMcp(options) {
         clientUri,
         callbackUrl,
         preventAutoAuth,
+        useRedirectFlow,
         onPopupWindow
       });
       addLog("debug", "BrowserOAuthClientProvider initialized in connect.");
@@ -254,6 +259,42 @@ function useMcp(options) {
       } catch (err) {
         const errorMessage = err?.message || String(err);
         if (err.code === 401 || errorMessage.includes("401") || errorMessage.includes("Unauthorized")) {
+          if (authProviderRef.current) {
+            addLog(
+              "info",
+              "Authentication required. OAuth provider available."
+            );
+            try {
+              const { auth } = await import("@modelcontextprotocol/sdk/client/auth.js");
+              const baseUrl = new URL(url).origin;
+              auth(authProviderRef.current, { serverUrl: baseUrl }).catch(
+                () => {
+                }
+              );
+              setTimeout(() => {
+                if (isMountedRef.current) {
+                  const manualUrl = authProviderRef.current?.getLastAttemptedAuthUrl();
+                  if (manualUrl) {
+                    setAuthUrl(manualUrl);
+                    addLog(
+                      "info",
+                      "Manual authentication URL available:",
+                      manualUrl
+                    );
+                  } else {
+                    addLog("warn", "Could not generate authentication URL");
+                  }
+                }
+              }, 100);
+            } catch (authGenError) {
+              addLog("warn", "Error generating auth URL:", authGenError);
+            }
+            if (isMountedRef.current) {
+              setState("pending_auth");
+            }
+            connectingRef.current = false;
+            return "auth_redirect";
+          }
           if (customHeaders && Object.keys(customHeaders).length > 0) {
             failConnection(
               "Authentication failed: Server returned 401 Unauthorized. Check your Authorization header value is correct."
@@ -305,6 +346,7 @@ function useMcp(options) {
     customHeaders,
     transportType,
     preventAutoAuth,
+    useRedirectFlow,
     onPopupWindow,
     enabled,
     timeout,
@@ -357,32 +399,54 @@ function useMcp(options) {
       retry();
     } else if (currentState === "pending_auth") {
       addLog("info", "Proceeding with authentication from pending state...");
-      setState("authenticating");
-      if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-      authTimeoutRef.current = setTimeout(() => {
-        if (isMountedRef.current) {
-          const currentStateValue = stateRef.current;
-          if (currentStateValue === "authenticating") {
-            failConnection("Authentication timed out. Please try again.");
-          }
-        }
-      }, AUTH_TIMEOUT);
       try {
         assert(
           authProviderRef.current,
           "Auth Provider not available for manual auth"
         );
         assert(url, "Server URL is required for authentication");
-        addLog(
-          "info",
-          "Redirecting for manual authentication. Waiting for callback..."
-        );
+        addLog("info", "Clearing all OAuth state and initiating fresh flow...");
+        const hashPrefix = `${storageKeyPrefix}:${authProviderRef.current.serverUrlHash}`;
+        Object.keys(localStorage).forEach((key) => {
+          if (key.startsWith(hashPrefix)) {
+            addLog("debug", `Removing stale OAuth key: ${key}`);
+            localStorage.removeItem(key);
+          }
+          if (key.startsWith(`${storageKeyPrefix}:state_`)) {
+            addLog("debug", `Removing orphaned state: ${key}`);
+            localStorage.removeItem(key);
+          }
+        });
+        setState("authenticating");
+        const freshAuthProvider = new BrowserOAuthClientProvider(url, {
+          storageKeyPrefix,
+          clientName,
+          clientUri,
+          callbackUrl,
+          preventAutoAuth: false,
+          // ← Allow OAuth to proceed
+          useRedirectFlow,
+          onPopupWindow
+        });
+        authProviderRef.current = freshAuthProvider;
+        addLog("info", "Triggering fresh OAuth authorization...");
+        const { auth } = await import("@modelcontextprotocol/sdk/client/auth.js");
+        const baseUrl = new URL(url).origin;
+        auth(freshAuthProvider, {
+          serverUrl: baseUrl
+        }).catch((err) => {
+          addLog(
+            "info",
+            "OAuth flow initiated:",
+            err?.message || "Redirecting..."
+          );
+        });
       } catch (authError) {
         if (!isMountedRef.current) return;
-        if (authTimeoutRef.current) clearTimeout(authTimeoutRef.current);
-        failConnection(
-          `Manual authentication failed: ${authError instanceof Error ? authError.message : String(authError)}`,
-          authError instanceof Error ? authError : void 0
+        setState("pending_auth");
+        addLog(
+          "error",
+          `Manual authentication failed: ${authError instanceof Error ? authError.message : String(authError)}`
         );
       }
     } else if (currentState === "authenticating") {
@@ -401,7 +465,18 @@ function useMcp(options) {
         `Client not in a state requiring manual authentication trigger (state: ${currentState}). If needed, try disconnecting and reconnecting.`
       );
     }
-  }, [addLog, retry, authUrl, url, failConnection, connect]);
+  }, [
+    addLog,
+    retry,
+    authUrl,
+    url,
+    useRedirectFlow,
+    onPopupWindow,
+    storageKeyPrefix,
+    clientName,
+    clientUri,
+    callbackUrl
+  ]);
   const clearStorage = useCallback(() => {
     if (authProviderRef.current) {
       const count = authProviderRef.current.clearStorage();
@@ -572,6 +647,7 @@ function useMcp(options) {
         clientUri,
         callbackUrl,
         preventAutoAuth,
+        useRedirectFlow,
         onPopupWindow
       });
       addLog(
@@ -593,7 +669,8 @@ function useMcp(options) {
     clientName,
     clientUri,
     clientConfig.name,
-    clientConfig.version
+    clientConfig.version,
+    useRedirectFlow
   ]);
   useEffect(() => {
     let retryTimeoutId = null;
@@ -1414,7 +1491,18 @@ __name(WidgetControls, "WidgetControls");
 
 // src/react/McpUseProvider.tsx
 import React5, { StrictMode, useCallback as useCallback3, useEffect as useEffect5, useRef as useRef3 } from "react";
-import { BrowserRouter } from "react-router-dom";
+var BrowserRouter = null;
+var routerError = null;
+(async () => {
+  try {
+    const routerModule = await import("react-router-dom");
+    BrowserRouter = routerModule.BrowserRouter;
+  } catch (error) {
+    routerError = new Error(
+      "\u274C react-router-dom not installed!\n\nTo use MCP widgets with McpUseProvider, you need to install:\n\n  npm install react-router-dom\n  # or\n  pnpm add react-router-dom\n\nThis dependency is automatically included in projects created with 'create-mcp-use-app'."
+    );
+  }
+})();
 function getBasename() {
   if (typeof window === "undefined") return "/";
   const path = window.location.pathname;
@@ -1508,6 +1596,12 @@ function McpUseProvider({
   if (enableDebugger || viewControls) {
     content = /* @__PURE__ */ React5.createElement(WidgetControls, { debugger: enableDebugger, viewControls }, content);
   }
+  if (routerError) {
+    throw routerError;
+  }
+  if (!BrowserRouter) {
+    throw new Error("react-router-dom is still loading, please try again.");
+  }
   content = /* @__PURE__ */ React5.createElement(BrowserRouter, { basename }, content);
   content = /* @__PURE__ */ React5.createElement(ThemeProvider, null, content);
   if (autoSize) {

package/dist/{chunk-YURRUCIM.js → chunk-CPG2WZUL.js}

@@ -6,8 +6,6 @@ import {
 } from "./chunk-3GQAWCBQ.js";
 
 // src/observability/langfuse.ts
-import { config } from "dotenv";
-config();
 var langfuseDisabled = process.env.MCP_USE_LANGFUSE?.toLowerCase() === "false";
 var langfuseState = {
   handler: null,
@@ -33,13 +31,13 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
       metadataProvider;
       tagsProvider;
       verbose;
-      constructor(config3, agentId2, metadata2, metadataProvider2, tagsProvider2) {
-        super(config3);
+      constructor(config2, agentId2, metadata2, metadataProvider2, tagsProvider2) {
+        super(config2);
         this.agentId = agentId2;
         this.metadata = metadata2;
         this.metadataProvider = metadataProvider2;
         this.tagsProvider = tagsProvider2;
-        this.verbose = config3?.verbose ?? false;
+        this.verbose = config2?.verbose ?? false;
       }
       // Override to add custom metadata to traces
       async handleChainStart(chain, inputs, runId, parentRunId, tags, metadata2, name, kwargs) {
@@ -164,7 +162,7 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
     }
     const initialMetadata = metadata || (metadataProvider ? metadataProvider() : {});
     const initialTags = tagsProvider ? tagsProvider() : [];
-    const config2 = {
+    const config = {
       publicKey: process.env.LANGFUSE_PUBLIC_KEY,
       secretKey: process.env.LANGFUSE_SECRET_KEY,
       baseUrl: process.env.LANGFUSE_HOST || process.env.LANGFUSE_BASEURL || "https://cloud.langfuse.com",
@@ -189,17 +187,17 @@ async function initializeLangfuse(agentId, metadata, metadataProvider, tagsProvi
       "Langfuse handler config:",
       JSON.stringify(
         {
-          traceName: config2.traceName,
-          sessionId: config2.sessionId,
-          userId: config2.userId,
-          tags: config2.tags
+          traceName: config.traceName,
+          sessionId: config.sessionId,
+          userId: config.userId,
+          tags: config.tags
         },
         null,
         2
       )
     );
     langfuseState.handler = new LoggingCallbackHandler(
-      config2,
+      config,
       agentId,
       metadata,
       metadataProvider,