mcp-ts-template 2.4.1 → 2.4.2

package/dist/index.js

@@ -29010,7 +29010,7 @@ var require_gaxios = __commonJS((exports) => {
   function hasFetch() {
     return hasWindow() && !!window.fetch;
   }
-  function hasBuffer() {
+  function hasBuffer2() {
     return typeof Buffer !== "undefined";
   }
   function hasHeader(options, header) {
@@ -29236,7 +29236,7 @@ Content-Type: ${partContentType}\r
       const isFormData = typeof FormData === "undefined" ? false : (opts === null || opts === undefined ? undefined : opts.data) instanceof FormData;
       if (is_stream_1.default.readable(opts.data)) {
         opts.body = opts.data;
-      } else if (hasBuffer() && Buffer.isBuffer(opts.data)) {
+      } else if (hasBuffer2() && Buffer.isBuffer(opts.data)) {
         opts.body = opts.data;
         if (!hasHeader(opts, "Content-Type")) {
           opts.headers["Content-Type"] = "application/json";
@@ -117645,81 +117645,175 @@ var config = parseConfig();
 
 // src/utils/telemetry/instrumentation.ts
 var import_api = __toESM(require_src(), 1);
-var import_auto_instrumentations_node = __toESM(require_src58(), 1);
-var import_exporter_metrics_otlp_http = __toESM(require_src62(), 1);
-var import_exporter_trace_otlp_http = __toESM(require_src63(), 1);
-var import_instrumentation_pino = __toESM(require_src40(), 1);
-var import_resources = __toESM(require_src52(), 1);
-var import_sdk_metrics = __toESM(require_src59(), 1);
-var import_sdk_node = __toESM(require_src83(), 1);
-var import_sdk_trace_node = __toESM(require_src67(), 1);
-var import_incubating = __toESM(require_index_incubating(), 1);
+
+// src/utils/internal/runtime.ts
+var safeHas = (key) => {
+  try {
+    return typeof globalThis[key] !== "undefined";
+  } catch {
+    return false;
+  }
+};
+var isNode = typeof process !== "undefined" && typeof process.versions?.node === "string";
+var hasProcess = typeof process !== "undefined";
+var hasBuffer = typeof Buffer !== "undefined";
+var hasTextEncoder = safeHas("TextEncoder");
+var hasPerformanceNow = typeof globalThis.performance?.now === "function";
+var isWorkerLike = !isNode && typeof globalThis.WorkerGlobalScope !== "undefined";
+var isBrowserLike = !isNode && !isWorkerLike && safeHas("window");
+var runtimeCaps = {
+  isNode,
+  isWorkerLike,
+  isBrowserLike,
+  hasProcess,
+  hasBuffer,
+  hasTextEncoder,
+  hasPerformanceNow
+};
+
+// src/utils/telemetry/instrumentation.ts
 var sdk = null;
 var isOtelInitialized = false;
-if (config.openTelemetry.enabled && !isOtelInitialized) {
-  isOtelInitialized = true;
-  try {
-    const otelLogLevelString = config.openTelemetry.logLevel.toUpperCase();
-    const otelLogLevel = import_api.DiagLogLevel[otelLogLevelString] ?? import_api.DiagLogLevel.INFO;
-    import_api.diag.setLogger(new import_api.DiagConsoleLogger, otelLogLevel);
-    const tracesEndpoint = config.openTelemetry.tracesEndpoint;
-    const metricsEndpoint = config.openTelemetry.metricsEndpoint;
-    if (!tracesEndpoint && !metricsEndpoint) {
-      import_api.diag.warn("OTEL_ENABLED is true, but no OTLP endpoint for traces or metrics is configured. OpenTelemetry will not export any telemetry.");
-    }
-    const resource = import_resources.resourceFromAttributes({
-      [import_incubating.ATTR_SERVICE_NAME]: config.openTelemetry.serviceName,
-      [import_incubating.ATTR_SERVICE_VERSION]: config.openTelemetry.serviceVersion,
-      "deployment.environment.name": config.environment
-    });
-    const spanProcessors = [];
-    if (tracesEndpoint) {
-      import_api.diag.info(`Using OTLP exporter for traces, endpoint: ${tracesEndpoint}`);
-      const traceExporter = new import_exporter_trace_otlp_http.OTLPTraceExporter({ url: tracesEndpoint });
-      spanProcessors.push(new import_sdk_trace_node.BatchSpanProcessor(traceExporter));
-    } else {
-      import_api.diag.info("No OTLP traces endpoint configured. Traces will not be exported.");
-    }
-    const metricReader = metricsEndpoint ? new import_sdk_metrics.PeriodicExportingMetricReader({
-      exporter: new import_exporter_metrics_otlp_http.OTLPMetricExporter({ url: metricsEndpoint }),
-      exportIntervalMillis: 15000
-    }) : undefined;
-    sdk = new import_sdk_node.NodeSDK({
-      resource,
-      spanProcessors,
-      ...metricReader && { metricReader },
-      sampler: new import_sdk_trace_node.TraceIdRatioBasedSampler(config.openTelemetry.samplingRatio),
-      instrumentations: [
-        import_auto_instrumentations_node.getNodeAutoInstrumentations({
-          "@opentelemetry/instrumentation-http": {
-            enabled: true,
-            ignoreIncomingRequestHook: (req) => req.url === "/healthz"
-          },
-          "@opentelemetry/instrumentation-fs": { enabled: false }
-        }),
-        new import_instrumentation_pino.PinoInstrumentation({
-          logHook: (_span, record) => {
-            record["trace_id"] = _span.spanContext().traceId;
-            record["span_id"] = _span.spanContext().spanId;
-          }
-        })
-      ]
-    });
-    sdk.start();
-    import_api.diag.info(`OpenTelemetry initialized for ${config.openTelemetry.serviceName} v${config.openTelemetry.serviceVersion}`);
-  } catch (error) {
-    import_api.diag.error("Error initializing OpenTelemetry", error);
-    sdk = null;
+var initializationPromise = null;
+function canUseNodeSDK() {
+  return runtimeCaps.isNode && typeof process?.versions?.node === "string" && typeof process.env === "object";
+}
+function detectCloudResource() {
+  const attrs = {};
+  if (runtimeCaps.isWorkerLike) {
+    attrs["cloud.provider"] = "cloudflare";
+    attrs["cloud.platform"] = "cloudflare_workers";
+  }
+  if (typeof process !== "undefined" && process.env?.AWS_LAMBDA_FUNCTION_NAME) {
+    attrs["cloud.provider"] = "aws";
+    attrs["cloud.platform"] = "aws_lambda";
+    if (process.env.AWS_REGION) {
+      attrs["cloud.region"] = process.env.AWS_REGION;
+    }
+  }
+  if (typeof process !== "undefined" && (process.env?.FUNCTION_TARGET || process.env?.K_SERVICE)) {
+    attrs["cloud.provider"] = "gcp";
+    attrs["cloud.platform"] = process.env.FUNCTION_TARGET ? "gcp_cloud_functions" : "gcp_cloud_run";
+    if (process.env.GCP_REGION) {
+      attrs["cloud.region"] = process.env.GCP_REGION;
+    }
   }
+  attrs["deployment.environment.name"] = config.environment;
+  return attrs;
 }
-async function shutdownOpenTelemetry() {
-  if (sdk) {
+async function initializeOpenTelemetry() {
+  if (initializationPromise) {
+    return initializationPromise;
+  }
+  if (isOtelInitialized) {
+    return;
+  }
+  initializationPromise = (async () => {
+    if (!config.openTelemetry.enabled) {
+      import_api.diag.info("OpenTelemetry disabled via configuration.");
+      isOtelInitialized = true;
+      return;
+    }
+    if (!canUseNodeSDK()) {
+      import_api.diag.info("NodeSDK unavailable in this runtime. Using lightweight telemetry mode.");
+      isOtelInitialized = true;
+      return;
+    }
+    isOtelInitialized = true;
     try {
-      await sdk.shutdown();
-      import_api.diag.info("OpenTelemetry terminated successfully.");
+      const [
+        { getNodeAutoInstrumentations },
+        { OTLPMetricExporter },
+        { OTLPTraceExporter },
+        { PinoInstrumentation },
+        { resourceFromAttributes },
+        { PeriodicExportingMetricReader },
+        { NodeSDK },
+        { BatchSpanProcessor, TraceIdRatioBasedSampler },
+        { ATTR_SERVICE_NAME, ATTR_SERVICE_VERSION }
+      ] = await Promise.all([
+        Promise.resolve().then(() => __toESM(require_src58(), 1)),
+        Promise.resolve().then(() => __toESM(require_src62(), 1)),
+        Promise.resolve().then(() => __toESM(require_src63(), 1)),
+        Promise.resolve().then(() => __toESM(require_src40(), 1)),
+        Promise.resolve().then(() => __toESM(require_src52(), 1)),
+        Promise.resolve().then(() => __toESM(require_src59(), 1)),
+        Promise.resolve().then(() => __toESM(require_src83(), 1)),
+        Promise.resolve().then(() => __toESM(require_src67(), 1)),
+        Promise.resolve().then(() => __toESM(require_index_incubating(), 1))
+      ]);
+      const otelLogLevelString = config.openTelemetry.logLevel.toUpperCase();
+      const otelLogLevel = import_api.DiagLogLevel[otelLogLevelString] ?? import_api.DiagLogLevel.INFO;
+      import_api.diag.setLogger(new import_api.DiagConsoleLogger, otelLogLevel);
+      const tracesEndpoint = config.openTelemetry.tracesEndpoint;
+      const metricsEndpoint = config.openTelemetry.metricsEndpoint;
+      if (!tracesEndpoint && !metricsEndpoint) {
+        import_api.diag.warn("OTEL_ENABLED is true, but no OTLP endpoint for traces or metrics is configured. OpenTelemetry will not export any telemetry.");
+      }
+      const resource = resourceFromAttributes({
+        [ATTR_SERVICE_NAME]: config.openTelemetry.serviceName,
+        [ATTR_SERVICE_VERSION]: config.openTelemetry.serviceVersion,
+        ...detectCloudResource()
+      });
+      const spanProcessors = [];
+      if (tracesEndpoint) {
+        import_api.diag.info(`Using OTLP exporter for traces, endpoint: ${tracesEndpoint}`);
+        const traceExporter = new OTLPTraceExporter({ url: tracesEndpoint });
+        spanProcessors.push(new BatchSpanProcessor(traceExporter));
+      } else {
+        import_api.diag.info("No OTLP traces endpoint configured. Traces will not be exported.");
+      }
+      const metricReader = metricsEndpoint ? new PeriodicExportingMetricReader({
+        exporter: new OTLPMetricExporter({ url: metricsEndpoint }),
+        exportIntervalMillis: 15000
+      }) : undefined;
+      sdk = new NodeSDK({
+        resource,
+        spanProcessors,
+        ...metricReader && { metricReader },
+        sampler: new TraceIdRatioBasedSampler(config.openTelemetry.samplingRatio),
+        instrumentations: [
+          getNodeAutoInstrumentations({
+            "@opentelemetry/instrumentation-http": {
+              enabled: true,
+              ignoreIncomingRequestHook: (req) => req.url === "/healthz"
+            },
+            "@opentelemetry/instrumentation-fs": { enabled: false }
+          }),
+          new PinoInstrumentation({
+            logHook: (_span, record) => {
+              record["trace_id"] = _span.spanContext().traceId;
+              record["span_id"] = _span.spanContext().spanId;
+            }
+          })
+        ]
+      });
+      sdk.start();
+      import_api.diag.info(`OpenTelemetry NodeSDK initialized for ${config.openTelemetry.serviceName} v${config.openTelemetry.serviceVersion}`);
     } catch (error) {
-      import_api.diag.error("Error terminating OpenTelemetry", error);
+      import_api.diag.error("Error initializing OpenTelemetry", error);
+      sdk = null;
+      throw error;
     }
+  })();
+  return initializationPromise;
+}
+async function shutdownOpenTelemetry(timeoutMs = 5000) {
+  if (!sdk) {
+    return;
+  }
+  try {
+    const shutdownPromise = sdk.shutdown();
+    const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("OpenTelemetry SDK shutdown timeout")), timeoutMs));
+    await Promise.race([shutdownPromise, timeoutPromise]);
+    import_api.diag.info("OpenTelemetry SDK terminated successfully.");
+  } catch (error) {
+    import_api.diag.error("Error terminating OpenTelemetry SDK", error);
+    throw error;
+  } finally {
+    sdk = null;
+    isOtelInitialized = false;
+    initializationPromise = null;
   }
 }
 
@@ -118457,6 +118551,25 @@ class Logger {
 var logger = Logger.getInstance();
 
 // src/utils/internal/error-handler/mappings.ts
+var COMPILED_PATTERN_CACHE = new Map;
+function getCompiledPattern(pattern) {
+  const cacheKey = pattern instanceof RegExp ? pattern.source + pattern.flags : pattern;
+  if (COMPILED_PATTERN_CACHE.has(cacheKey)) {
+    return COMPILED_PATTERN_CACHE.get(cacheKey);
+  }
+  let compiled;
+  if (pattern instanceof RegExp) {
+    let flags = pattern.flags.replace("g", "");
+    if (!flags.includes("i")) {
+      flags += "i";
+    }
+    compiled = new RegExp(pattern.source, flags);
+  } else {
+    compiled = new RegExp(pattern, "i");
+  }
+  COMPILED_PATTERN_CACHE.set(cacheKey, compiled);
+  return compiled;
+}
 var ERROR_TYPE_MAPPINGS = {
   SyntaxError: -32007 /* ValidationError */,
   TypeError: -32007 /* ValidationError */,
@@ -118508,17 +118621,76 @@ var COMMON_ERROR_PATTERNS = [
     errorCode: -32007 /* ValidationError */
   }
 ];
+var COMPILED_ERROR_PATTERNS = COMMON_ERROR_PATTERNS.map((mapping) => ({
+  ...mapping,
+  compiledPattern: getCompiledPattern(mapping.pattern)
+}));
+var PROVIDER_ERROR_PATTERNS = [
+  {
+    pattern: /ThrottlingException|TooManyRequestsException/i,
+    errorCode: -32003 /* RateLimited */
+  },
+  {
+    pattern: /AccessDenied|UnauthorizedOperation/i,
+    errorCode: -32005 /* Forbidden */
+  },
+  {
+    pattern: /ResourceNotFoundException/i,
+    errorCode: -32001 /* NotFound */
+  },
+  { pattern: /status code 401/i, errorCode: -32006 /* Unauthorized */ },
+  { pattern: /status code 403/i, errorCode: -32005 /* Forbidden */ },
+  { pattern: /status code 404/i, errorCode: -32001 /* NotFound */ },
+  { pattern: /status code 409/i, errorCode: -32002 /* Conflict */ },
+  { pattern: /status code 429/i, errorCode: -32003 /* RateLimited */ },
+  {
+    pattern: /status code 5\d\d/i,
+    errorCode: -32000 /* ServiceUnavailable */
+  },
+  {
+    pattern: /ECONNREFUSED|connection refused/i,
+    errorCode: -32000 /* ServiceUnavailable */
+  },
+  {
+    pattern: /ETIMEDOUT|connection timeout/i,
+    errorCode: -32004 /* Timeout */
+  },
+  {
+    pattern: /unique constraint|duplicate key/i,
+    errorCode: -32002 /* Conflict */
+  },
+  {
+    pattern: /foreign key constraint/i,
+    errorCode: -32007 /* ValidationError */
+  },
+  { pattern: /JWT expired/i, errorCode: -32006 /* Unauthorized */ },
+  {
+    pattern: /row level security/i,
+    errorCode: -32005 /* Forbidden */
+  },
+  {
+    pattern: /insufficient_quota|quota exceeded/i,
+    errorCode: -32003 /* RateLimited */
+  },
+  { pattern: /model_not_found/i, errorCode: -32001 /* NotFound */ },
+  {
+    pattern: /context_length_exceeded/i,
+    errorCode: -32007 /* ValidationError */
+  },
+  { pattern: /ENOTFOUND|DNS/i, errorCode: -32000 /* ServiceUnavailable */ },
+  {
+    pattern: /ECONNRESET|connection reset/i,
+    errorCode: -32000 /* ServiceUnavailable */
+  }
+];
+var COMPILED_PROVIDER_PATTERNS = PROVIDER_ERROR_PATTERNS.map((mapping) => ({
+  ...mapping,
+  compiledPattern: getCompiledPattern(mapping.pattern)
+}));
 
 // src/utils/internal/error-handler/helpers.ts
 function createSafeRegex(pattern) {
-  if (pattern instanceof RegExp) {
-    let flags = pattern.flags.replace("g", "");
-    if (!flags.includes("i")) {
-      flags += "i";
-    }
-    return new RegExp(pattern.source, flags);
-  }
-  return new RegExp(pattern, "i");
+  return getCompiledPattern(pattern);
 }
 function getErrorName(error) {
   if (error instanceof Error) {
@@ -118579,6 +118751,61 @@ function getErrorMessage(error) {
     return `Error converting error to string: ${conversionError instanceof Error ? conversionError.message : "Unknown conversion error"}`;
   }
 }
+function extractErrorCauseChain(error, maxDepth = 20) {
+  const chain = [];
+  const seen = new WeakSet;
+  let current = error;
+  let depth = 0;
+  while (current && depth < maxDepth) {
+    if (typeof current === "object" && current !== null) {
+      if (seen.has(current)) {
+        chain.push({
+          name: "CircularReference",
+          message: "Circular reference detected in error cause chain",
+          depth
+        });
+        break;
+      }
+      seen.add(current);
+    }
+    if (current instanceof Error) {
+      const node = {
+        name: current.name,
+        message: current.message,
+        depth,
+        ...current.stack !== undefined ? { stack: current.stack } : {}
+      };
+      if (current instanceof McpError && current.data) {
+        node.data = current.data;
+      }
+      chain.push(node);
+      current = current.cause;
+    } else if (typeof current === "string") {
+      chain.push({
+        name: "StringError",
+        message: current,
+        depth
+      });
+      break;
+    } else {
+      chain.push({
+        name: getErrorName(current),
+        message: getErrorMessage(current),
+        depth
+      });
+      break;
+    }
+    depth++;
+  }
+  if (depth >= maxDepth) {
+    chain.push({
+      name: "MaxDepthExceeded",
+      message: `Error cause chain exceeded maximum depth of ${maxDepth}`,
+      depth
+    });
+  }
+  return chain;
+}
 
 // src/utils/internal/error-handler/errorHandler.ts
 class ErrorHandler {
@@ -118592,9 +118819,13 @@ class ErrorHandler {
     if (mappedFromType) {
       return mappedFromType;
     }
-    for (const mapping of COMMON_ERROR_PATTERNS) {
-      const regex = createSafeRegex(mapping.pattern);
-      if (regex.test(errorMessage) || regex.test(errorName)) {
+    for (const mapping of COMPILED_PROVIDER_PATTERNS) {
+      if (mapping.compiledPattern.test(errorMessage) || mapping.compiledPattern.test(errorName)) {
+        return mapping.errorCode;
+      }
+    }
+    for (const mapping of COMPILED_ERROR_PATTERNS) {
+      if (mapping.compiledPattern.test(errorMessage) || mapping.compiledPattern.test(errorName)) {
         return mapping.errorCode;
       }
     }
@@ -118641,17 +118872,19 @@ class ErrorHandler {
       consolidatedData.originalStack = originalStack;
     }
     const cause = error instanceof Error ? error : undefined;
-    const rootCause = (() => {
-      let current = cause;
-      let depth = 0;
-      while (current && current instanceof Error && current.cause && depth < 5) {
-        current = current.cause;
-        depth += 1;
+    const causeChain = extractErrorCauseChain(error);
+    if (causeChain.length > 0) {
+      const rootCause = causeChain[causeChain.length - 1];
+      if (rootCause) {
+        consolidatedData["rootCause"] = {
+          name: rootCause.name,
+          message: rootCause.message
+        };
       }
-      return current instanceof Error ? { name: current.name, message: current.message } : undefined;
-    })();
-    if (rootCause) {
-      consolidatedData["rootCause"] = rootCause;
+      consolidatedData["causeChain"] = causeChain;
+    }
+    if (context && "metadata" in context && context.metadata && typeof context.metadata === "object" && "breadcrumbs" in context.metadata) {
+      consolidatedData["breadcrumbs"] = context.metadata.breadcrumbs;
     }
     if (error instanceof McpError) {
       loggedErrorCode = error.code;
@@ -118735,32 +118968,119 @@ class ErrorHandler {
       });
     }
   }
-}
-// src/utils/internal/runtime.ts
-var safeHas = (key) => {
-  try {
-    return typeof globalThis[key] !== "undefined";
-  } catch {
-    return false;
+  static async tryAsResult(fn, options) {
+    try {
+      const value = await Promise.resolve(fn());
+      return { ok: true, value };
+    } catch (caughtError) {
+      const error = ErrorHandler.handleError(caughtError, {
+        ...options,
+        rethrow: false
+      });
+      return { ok: false, error };
+    }
   }
-};
-var isNode = typeof process !== "undefined" && typeof process.versions?.node === "string";
-var hasProcess = typeof process !== "undefined";
-var hasBuffer = typeof Buffer !== "undefined";
-var hasTextEncoder = safeHas("TextEncoder");
-var hasPerformanceNow = typeof globalThis.performance?.now === "function";
-var isWorkerLike = !isNode && typeof globalThis.WorkerGlobalScope !== "undefined";
-var isBrowserLike = !isNode && !isWorkerLike && safeHas("window");
-var runtimeCaps = {
-  isNode,
-  isWorkerLike,
-  isBrowserLike,
-  hasProcess,
-  hasBuffer,
-  hasTextEncoder,
-  hasPerformanceNow
-};
-
+  static mapResult(result, fn) {
+    if (result.ok) {
+      try {
+        return { ok: true, value: fn(result.value) };
+      } catch (error) {
+        return {
+          ok: false,
+          error: new McpError(-32603 /* InternalError */, `Error mapping result: ${getErrorMessage(error)}`)
+        };
+      }
+    }
+    return result;
+  }
+  static flatMapResult(result, fn) {
+    if (result.ok) {
+      return fn(result.value);
+    }
+    return result;
+  }
+  static recoverResult(result, fallback) {
+    if (result.ok) {
+      return result.value;
+    }
+    return typeof fallback === "function" ? fallback(result.error) : fallback;
+  }
+  static addBreadcrumb(context, operation, additionalData) {
+    const breadcrumbs = context.metadata?.breadcrumbs || [];
+    breadcrumbs.push({
+      timestamp: new Date().toISOString(),
+      operation,
+      ...additionalData !== undefined ? { context: additionalData } : {}
+    });
+    return {
+      ...context,
+      metadata: {
+        ...context.metadata,
+        breadcrumbs
+      }
+    };
+  }
+  static async tryCatchWithRetry(fn, options, strategy) {
+    let lastError;
+    for (let attempt = 1;attempt <= strategy.maxAttempts; attempt++) {
+      try {
+        return await Promise.resolve(fn());
+      } catch (caughtError) {
+        lastError = caughtError instanceof Error ? caughtError : new Error(String(caughtError));
+        if (attempt < strategy.maxAttempts && strategy.shouldRetry(lastError, attempt)) {
+          const delay = strategy.getRetryDelay(attempt);
+          const retryContext = {
+            ...options.context,
+            requestId: options.context?.requestId || generateUUID(),
+            timestamp: new Date().toISOString(),
+            operation: options.operation,
+            error: lastError.message,
+            attempt
+          };
+          logger.warning(`Retry attempt ${attempt}/${strategy.maxAttempts} after ${delay}ms`, retryContext);
+          strategy.onRetry?.(lastError, attempt);
+          await new Promise((resolve) => setTimeout(resolve, delay));
+        } else {
+          throw ErrorHandler.handleError(lastError, {
+            ...options,
+            rethrow: true,
+            context: {
+              ...options.context,
+              retryAttempts: attempt,
+              finalAttempt: true
+            }
+          });
+        }
+      }
+    }
+    throw ErrorHandler.handleError(lastError, {
+      ...options,
+      rethrow: true
+    });
+  }
+  static createExponentialBackoffStrategy(maxAttempts = 3, baseDelay = 1000, maxDelay = 30000) {
+    return {
+      maxAttempts,
+      shouldRetry: (error) => {
+        if (error instanceof McpError) {
+          const nonRetryableCodes = [
+            -32007 /* ValidationError */,
+            -32006 /* Unauthorized */,
+            -32005 /* Forbidden */,
+            -32001 /* NotFound */
+          ];
+          return !nonRetryableCodes.includes(error.code);
+        }
+        return true;
+      },
+      getRetryDelay: (attemptNumber) => {
+        const exponentialDelay = baseDelay * Math.pow(2, attemptNumber - 1);
+        const jitter = Math.random() * 0.3 * exponentialDelay;
+        return Math.min(exponentialDelay + jitter, maxDelay);
+      }
+    };
+  }
+}
 // src/utils/internal/performance.ts
 var import_api4 = __toESM(require_src(), 1);
 
@@ -136482,6 +136802,11 @@ var start = async () => {
     await shutdownOpenTelemetry();
     process.exit(1);
   }
+  try {
+    await initializeOpenTelemetry();
+  } catch (error2) {
+    console.error("[Startup] Failed to initialize OpenTelemetry:", error2);
+  }
   await initializePerformance_Hrt();
   const validMcpLogLevels = [
     "debug",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-ts-template",
-  "version": "2.4.1",
+  "version": "2.4.2",
   "mcpName": "io.github.cyanheads/mcp-ts-template",
   "description": "The definitive, production-grade template for building powerful and scalable Model Context Protocol (MCP) servers with TypeScript, featuring built-in observability (OpenTelemetry), declarative tooling, robust error handling, and a modular, DI-driven architecture.",
   "main": "dist/index.js",