@cyanheads/git-mcp-server 2.1.0 → 2.1.2

package/dist/utils/internal/errorHandler.js

@@ -1,37 +1,61 @@
-import { BaseErrorCode, McpError } from '../../types-global/errors.js'; // Corrected path
-import { logger } from './logger.js';
-import { sanitizeInputForLogging } from '../index.js'; // Import from main barrel file
+import { BaseErrorCode, McpError } from "../../types-global/errors.js"; // Corrected path
+import { logger } from "./logger.js";
+import { sanitizeInputForLogging } from "../index.js"; // Import from main barrel file
 /**
  * Simple mapper that maps error types to error codes
  */
 const ERROR_TYPE_MAPPINGS = {
-    'SyntaxError': BaseErrorCode.VALIDATION_ERROR,
-    'TypeError': BaseErrorCode.VALIDATION_ERROR,
-    'ReferenceError': BaseErrorCode.INTERNAL_ERROR,
-    'RangeError': BaseErrorCode.VALIDATION_ERROR,
-    'URIError': BaseErrorCode.VALIDATION_ERROR,
-    'EvalError': BaseErrorCode.INTERNAL_ERROR
+    SyntaxError: BaseErrorCode.VALIDATION_ERROR,
+    TypeError: BaseErrorCode.VALIDATION_ERROR,
+    ReferenceError: BaseErrorCode.INTERNAL_ERROR,
+    RangeError: BaseErrorCode.VALIDATION_ERROR,
+    URIError: BaseErrorCode.VALIDATION_ERROR,
+    EvalError: BaseErrorCode.INTERNAL_ERROR,
 };
 /**
  * Common error patterns for automatic classification
  */
 const COMMON_ERROR_PATTERNS = [
     // Authentication related errors
-    { pattern: /auth|unauthorized|unauthenticated|not.*logged.*in|invalid.*token|expired.*token/i, errorCode: BaseErrorCode.UNAUTHORIZED },
+    {
+        pattern: /auth|unauthorized|unauthenticated|not.*logged.*in|invalid.*token|expired.*token/i,
+        errorCode: BaseErrorCode.UNAUTHORIZED,
+    },
     // Permission related errors
-    { pattern: /permission|forbidden|access.*denied|not.*allowed/i, errorCode: BaseErrorCode.FORBIDDEN },
+    {
+        pattern: /permission|forbidden|access.*denied|not.*allowed/i,
+        errorCode: BaseErrorCode.FORBIDDEN,
+    },
     // Not found errors
-    { pattern: /not.*found|missing|no.*such|doesn't.*exist|couldn't.*find/i, errorCode: BaseErrorCode.NOT_FOUND },
+    {
+        pattern: /not.*found|missing|no.*such|doesn't.*exist|couldn't.*find/i,
+        errorCode: BaseErrorCode.NOT_FOUND,
+    },
     // Validation errors
-    { pattern: /invalid|validation|malformed|bad request|wrong format/i, errorCode: BaseErrorCode.VALIDATION_ERROR },
+    {
+        pattern: /invalid|validation|malformed|bad request|wrong format/i,
+        errorCode: BaseErrorCode.VALIDATION_ERROR,
+    },
     // Conflict errors
-    { pattern: /conflict|already.*exists|duplicate|unique.*constraint/i, errorCode: BaseErrorCode.CONFLICT },
+    {
+        pattern: /conflict|already.*exists|duplicate|unique.*constraint/i,
+        errorCode: BaseErrorCode.CONFLICT,
+    },
     // Rate limiting
-    { pattern: /rate.*limit|too.*many.*requests|throttled/i, errorCode: BaseErrorCode.RATE_LIMITED },
+    {
+        pattern: /rate.*limit|too.*many.*requests|throttled/i,
+        errorCode: BaseErrorCode.RATE_LIMITED,
+    },
     // Timeout errors
-    { pattern: /timeout|timed.*out|deadline.*exceeded/i, errorCode: BaseErrorCode.TIMEOUT },
+    {
+        pattern: /timeout|timed.*out|deadline.*exceeded/i,
+        errorCode: BaseErrorCode.TIMEOUT,
+    },
     // External service errors
-    { pattern: /service.*unavailable|bad.*gateway|gateway.*timeout/i, errorCode: BaseErrorCode.SERVICE_UNAVAILABLE }
+    {
+        pattern: /service.*unavailable|bad.*gateway|gateway.*timeout/i,
+        errorCode: BaseErrorCode.SERVICE_UNAVAILABLE,
+    },
 ];
 /**
  * Get a readable name for an error
@@ -40,17 +64,15 @@ const COMMON_ERROR_PATTERNS = [
  */
 function getErrorName(error) {
     if (error instanceof Error) {
-        return error.name || 'Error';
+        return error.name || "Error";
     }
     if (error === null) {
-        return 'NullError';
+        return "NullError";
     }
     if (error === undefined) {
-        return 'UndefinedError';
+        return "UndefinedError";
     }
-    return typeof error === 'object'
-        ? 'ObjectError'
-        : 'UnknownError';
+    return typeof error === "object" ? "ObjectError" : "UnknownError";
 }
 /**
  * Get a message from an error
@@ -62,14 +84,12 @@ function getErrorMessage(error) {
         return error.message;
     }
     if (error === null) {
-        return 'Null error occurred';
+        return "Null error occurred";
     }
     if (error === undefined) {
-        return 'Undefined error occurred';
+        return "Undefined error occurred";
     }
-    return typeof error === 'string'
-        ? error
-        : String(error);
+    return typeof error === "string" ? error : String(error);
 }
 /**
  * Error handler utility class with various error handling methods
@@ -95,7 +115,7 @@ export class ErrorHandler {
         for (const pattern of COMMON_ERROR_PATTERNS) {
             const regex = pattern.pattern instanceof RegExp
                 ? pattern.pattern
-                : new RegExp(pattern.pattern, 'i');
+                : new RegExp(pattern.pattern, "i");
             if (regex.test(errorMessage) || regex.test(errorName)) {
                 return pattern.errorCode;
             }
@@ -110,13 +130,15 @@ export class ErrorHandler {
      * @returns The transformed error
      */
     static handleError(error, options) {
-        const { context, operation, input, rethrow = false, errorCode: explicitErrorCode, includeStack = true, critical = false } = options;
+        const { context, operation, input, rethrow = false, errorCode: explicitErrorCode, includeStack = true, critical = false, } = options;
         // If it's already an McpError, use it directly but apply additional context
         if (error instanceof McpError) {
             // Add any additional context
             if (context && Object.keys(context).length > 0) {
                 // Ensure details is an object before spreading
-                const existingDetails = typeof error.details === 'object' && error.details !== null ? error.details : {};
+                const existingDetails = typeof error.details === "object" && error.details !== null
+                    ? error.details
+                    : {};
                 error.details = { ...existingDetails, ...context };
             }
             // Log the error with sanitized input
@@ -126,7 +148,7 @@ export class ErrorHandler {
                 input: input ? sanitizeInputForLogging(input) : undefined,
                 stack: includeStack ? error.stack : undefined,
                 critical,
-                ...context
+                ...context,
             });
             if (rethrow) {
                 throw error;
@@ -144,7 +166,7 @@ export class ErrorHandler {
             requestId: context?.requestId,
             stack: includeStack && error instanceof Error ? error.stack : undefined,
             critical,
-            ...context
+            ...context,
         });
         // Choose the error code (explicit > determined > default)
         const errorCode = explicitErrorCode ||
@@ -159,7 +181,7 @@ export class ErrorHandler {
             transformedError = new McpError(errorCode, `Error ${operation}: ${getErrorMessage(error)}`, // Use helper function
             {
                 originalError: getErrorName(error),
-                ...context
+                ...context,
             });
         }
         // Rethrow if requested
@@ -198,9 +220,7 @@ export class ErrorHandler {
         if (defaultFactory) {
             return defaultFactory(error);
         }
-        return error instanceof Error
-            ? error
-            : new Error(String(error));
+        return error instanceof Error ? error : new Error(String(error));
     }
     // Removed createErrorMapper method for simplification
     /**
@@ -214,20 +234,22 @@ export class ErrorHandler {
                 code: error.code,
                 message: error.message,
                 // Ensure details is an object
-                details: typeof error.details === 'object' && error.details !== null ? error.details : {}
+                details: typeof error.details === "object" && error.details !== null
+                    ? error.details
+                    : {},
             };
         }
         if (error instanceof Error) {
             return {
                 code: ErrorHandler.determineErrorCode(error),
                 message: error.message,
-                details: { errorType: error.name }
+                details: { errorType: error.name },
             };
         }
         return {
             code: BaseErrorCode.UNKNOWN_ERROR,
             message: String(error),
-            details: { errorType: typeof error }
+            details: { errorType: typeof error },
         };
     }
     /**

package/dist/utils/internal/index.js

@@ -1,3 +1,3 @@
-export * from './errorHandler.js';
-export * from './logger.js';
-export * from './requestContext.js';
+export * from "./errorHandler.js";
+export * from "./logger.js";
+export * from "./requestContext.js";

package/dist/utils/internal/logger.js

@@ -1,35 +1,43 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import winston from 'winston';
-import { config } from '../../config/index.js';
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
+import winston from "winston";
+import { config } from "../../config/index.js";
 // Define the numeric severity for comparison (lower is more severe)
 const mcpLevelSeverity = {
-    emerg: 0, alert: 1, crit: 2, error: 3, warning: 4, notice: 5, info: 6, debug: 7
+    emerg: 0,
+    alert: 1,
+    crit: 2,
+    error: 3,
+    warning: 4,
+    notice: 5,
+    info: 6,
+    debug: 7,
 };
 // Map MCP levels to Winston's core levels for file logging
 const mcpToWinstonLevel = {
-    debug: 'debug',
-    info: 'info',
-    notice: 'info', // Map notice to info for file logging
-    warning: 'warn',
-    error: 'error',
-    crit: 'error', // Map critical levels to error for file logging
-    alert: 'error',
-    emerg: 'error',
+    debug: "debug",
+    info: "info",
+    notice: "info", // Map notice to info for file logging
+    warning: "warn",
+    error: "error",
+    crit: "error", // Map critical levels to error for file logging
+    alert: "error",
+    emerg: "error",
 };
 // Resolve __dirname for ESM
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 // Calculate project root robustly (works from src/ or dist/)
-const isRunningFromDist = __dirname.includes(path.sep + 'dist' + path.sep);
+const isRunningFromDist = __dirname.includes(path.sep + "dist" + path.sep);
 const levelsToGoUp = isRunningFromDist ? 3 : 2;
-const pathSegments = Array(levelsToGoUp).fill('..');
+const pathSegments = Array(levelsToGoUp).fill("..");
 const projectRoot = path.resolve(__dirname, ...pathSegments);
-const logsDir = path.join(projectRoot, 'logs');
+const logsDir = path.join(projectRoot, "logs");
 // Security: ensure logsDir is within projectRoot
 const resolvedLogsDir = path.resolve(logsDir);
-const isLogsDirSafe = resolvedLogsDir === projectRoot || resolvedLogsDir.startsWith(projectRoot + path.sep);
+const isLogsDirSafe = resolvedLogsDir === projectRoot ||
+    resolvedLogsDir.startsWith(projectRoot + path.sep);
 if (!isLogsDirSafe) {
     // Use console.error for critical pre-init errors.
     // Only log to console if TTY to avoid polluting stdout for stdio MCP clients.
@@ -42,21 +50,24 @@ if (!isLogsDirSafe) {
  * This is extracted to avoid duplication between initialize and setLevel.
  */
 function createWinstonConsoleFormat() {
-    return winston.format.combine(winston.format.colorize(), winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss' }), winston.format.printf(({ timestamp, level, message, ...meta }) => {
-        let metaString = '';
+    return winston.format.combine(winston.format.colorize(), winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }), winston.format.printf(({ timestamp, level, message, ...meta }) => {
+        let metaString = "";
         const metaCopy = { ...meta };
-        if (metaCopy.error && typeof metaCopy.error === 'object') {
+        if (metaCopy.error && typeof metaCopy.error === "object") {
             const errorObj = metaCopy.error;
             if (errorObj.message)
                 metaString += `\n  Error: ${errorObj.message}`;
             if (errorObj.stack)
-                metaString += `\n  Stack: ${String(errorObj.stack).split('\n').map((l) => `    ${l}`).join('\n')}`;
+                metaString += `\n  Stack: ${String(errorObj.stack)
+                    .split("\n")
+                    .map((l) => `    ${l}`)
+                    .join("\n")}`;
             delete metaCopy.error;
         }
         if (Object.keys(metaCopy).length > 0) {
             try {
                 const remainingMetaJson = JSON.stringify(metaCopy, null, 2);
-                if (remainingMetaJson !== '{}')
+                if (remainingMetaJson !== "{}")
                     metaString += `\n  Meta: ${remainingMetaJson}`;
             }
             catch (stringifyError) {
@@ -75,17 +86,17 @@ class Logger {
     winstonLogger;
     initialized = false;
     mcpNotificationSender;
-    currentMcpLevel = 'info'; // Default MCP level
-    currentWinstonLevel = 'info'; // Default Winston level
+    currentMcpLevel = "info"; // Default MCP level
+    currentWinstonLevel = "info"; // Default Winston level
     constructor() { }
     /**
      * Initialize Winston logger for file transport. Must be called once at app start.
      * Console transport is added conditionally.
      * @param level Initial minimum level to log ('info' default).
      */
-    async initialize(level = 'info') {
+    async initialize(level = "info") {
         if (this.initialized) {
-            this.warning('Logger already initialized.', { loggerSetup: true });
+            this.warning("Logger already initialized.", { loggerSetup: true });
             return;
         }
         this.currentMcpLevel = level;
@@ -111,7 +122,26 @@ class Logger {
         const transports = [];
         // Add file transports only if the directory is safe
         if (isLogsDirSafe) {
-            transports.push(new winston.transports.File({ filename: path.join(resolvedLogsDir, 'error.log'), level: 'error', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'warn.log'), level: 'warn', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'info.log'), level: 'info', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'debug.log'), level: 'debug', format: fileFormat }), new winston.transports.File({ filename: path.join(resolvedLogsDir, 'combined.log'), format: fileFormat }));
+            transports.push(new winston.transports.File({
+                filename: path.join(resolvedLogsDir, "error.log"),
+                level: "error",
+                format: fileFormat,
+            }), new winston.transports.File({
+                filename: path.join(resolvedLogsDir, "warn.log"),
+                level: "warn",
+                format: fileFormat,
+            }), new winston.transports.File({
+                filename: path.join(resolvedLogsDir, "info.log"),
+                level: "info",
+                format: fileFormat,
+            }), new winston.transports.File({
+                filename: path.join(resolvedLogsDir, "debug.log"),
+                level: "debug",
+                format: fileFormat,
+            }), new winston.transports.File({
+                filename: path.join(resolvedLogsDir, "combined.log"),
+                format: fileFormat,
+            }));
         }
         else {
             // Conditional console output for pre-init warnings.
@@ -124,22 +154,24 @@ class Logger {
         // Conditionally add Console transport only if:
         // 1. MCP level is 'debug'
         // 2. stdout is a TTY (interactive terminal, not piped)
-        if (this.currentMcpLevel === 'debug' && process.stdout.isTTY) {
+        if (this.currentMcpLevel === "debug" && process.stdout.isTTY) {
             const consoleFormat = createWinstonConsoleFormat();
             transports.push(new winston.transports.Console({
-                level: 'debug',
+                level: "debug",
                 format: consoleFormat,
             }));
-            consoleLoggingEnabledMessage = 'Console logging enabled at level: debug (stdout is TTY)';
+            consoleLoggingEnabledMessage =
+                "Console logging enabled at level: debug (stdout is TTY)";
         }
-        else if (this.currentMcpLevel === 'debug' && !process.stdout.isTTY) {
-            consoleLoggingSkippedMessage = 'Console logging skipped: Level is debug, but stdout is not a TTY (likely stdio transport).';
+        else if (this.currentMcpLevel === "debug" && !process.stdout.isTTY) {
+            consoleLoggingSkippedMessage =
+                "Console logging skipped: Level is debug, but stdout is not a TTY (likely stdio transport).";
         }
         // Create logger with the initial Winston level and configured transports
         this.winstonLogger = winston.createLogger({
             level: this.currentWinstonLevel,
             transports,
-            exitOnError: false
+            exitOnError: false,
         });
         // Log deferred messages now that winstonLogger is initialized
         if (logsDirCreatedMessage) {
@@ -153,14 +185,14 @@ class Logger {
         }
         this.initialized = true;
         await Promise.resolve(); // Yield to event loop
-        this.info(`Logger initialized. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${process.stdout.isTTY && this.currentMcpLevel === 'debug' ? 'enabled' : 'disabled'}`, { loggerSetup: true });
+        this.info(`Logger initialized. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${process.stdout.isTTY && this.currentMcpLevel === "debug" ? "enabled" : "disabled"}`, { loggerSetup: true });
     }
     /**
      * Sets the function used to send MCP 'notifications/message'.
      */
     setMcpNotificationSender(sender) {
         this.mcpNotificationSender = sender;
-        const status = sender ? 'enabled' : 'disabled';
+        const status = sender ? "enabled" : "disabled";
         this.info(`MCP notification sending ${status}.`, { loggerSetup: true });
     }
     /**
@@ -183,21 +215,24 @@ class Logger {
         this.currentWinstonLevel = mcpToWinstonLevel[newLevel];
         this.winstonLogger.level = this.currentWinstonLevel;
         // Add or remove console transport based on the new level and TTY status
-        const consoleTransport = this.winstonLogger.transports.find(t => t instanceof winston.transports.Console);
-        const shouldHaveConsole = newLevel === 'debug' && process.stdout.isTTY;
+        const consoleTransport = this.winstonLogger.transports.find((t) => t instanceof winston.transports.Console);
+        const shouldHaveConsole = newLevel === "debug" && process.stdout.isTTY;
         if (shouldHaveConsole && !consoleTransport) {
             // Add console transport
             const consoleFormat = createWinstonConsoleFormat();
-            this.winstonLogger.add(new winston.transports.Console({ level: 'debug', format: consoleFormat }));
-            this.info('Console logging dynamically enabled.', { loggerSetup: true });
+            this.winstonLogger.add(new winston.transports.Console({
+                level: "debug",
+                format: consoleFormat,
+            }));
+            this.info("Console logging dynamically enabled.", { loggerSetup: true });
         }
         else if (!shouldHaveConsole && consoleTransport) {
             // Remove console transport
             this.winstonLogger.remove(consoleTransport);
-            this.info('Console logging dynamically disabled.', { loggerSetup: true });
+            this.info("Console logging dynamically disabled.", { loggerSetup: true });
         }
         if (oldLevel !== newLevel) {
-            this.info(`Log level changed. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${shouldHaveConsole ? 'enabled' : 'disabled'}`, { loggerSetup: true });
+            this.info(`Log level changed. File logging level: ${this.currentWinstonLevel}. MCP logging level: ${this.currentMcpLevel}. Console logging: ${shouldHaveConsole ? "enabled" : "disabled"}`, { loggerSetup: true });
         }
     }
     /** Get singleton instance. */
@@ -212,7 +247,7 @@ class Logger {
         if (!this.initialized || !this.winstonLogger) {
             // Conditional console output if logger not usable.
             if (process.stdout.isTTY) {
-                console.warn('Logger not initialized; message dropped.');
+                console.warn("Logger not initialized; message dropped.");
             }
             return false;
         }
@@ -239,7 +274,7 @@ class Logger {
                 mcpDataPayload.context = context;
             if (error) {
                 mcpDataPayload.error = { message: error.message };
-                if (this.currentMcpLevel === 'debug' && error.stack) {
+                if (this.currentMcpLevel === "debug" && error.stack) {
                     mcpDataPayload.error.stack = error.stack.substring(0, 500);
                 }
             }
@@ -251,38 +286,46 @@ class Logger {
                     originalLevel: level,
                     originalMessage: msg,
                     sendError: sendError instanceof Error ? sendError.message : String(sendError),
-                    mcpPayload: mcpDataPayload
+                    mcpPayload: mcpDataPayload,
                 });
             }
         }
     }
     // --- Public Logging Methods ---
-    debug(msg, context) { this.log('debug', msg, context); }
-    info(msg, context) { this.log('info', msg, context); }
-    notice(msg, context) { this.log('notice', msg, context); }
-    warning(msg, context) { this.log('warning', msg, context); }
+    debug(msg, context) {
+        this.log("debug", msg, context);
+    }
+    info(msg, context) {
+        this.log("info", msg, context);
+    }
+    notice(msg, context) {
+        this.log("notice", msg, context);
+    }
+    warning(msg, context) {
+        this.log("warning", msg, context);
+    }
     error(msg, err, context) {
         const errorObj = err instanceof Error ? err : undefined;
         const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
-        this.log('error', msg, combinedContext, errorObj);
+        this.log("error", msg, combinedContext, errorObj);
     }
     crit(msg, err, context) {
         const errorObj = err instanceof Error ? err : undefined;
         const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
-        this.log('crit', msg, combinedContext, errorObj);
+        this.log("crit", msg, combinedContext, errorObj);
     }
     alert(msg, err, context) {
         const errorObj = err instanceof Error ? err : undefined;
         const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
-        this.log('alert', msg, combinedContext, errorObj);
+        this.log("alert", msg, combinedContext, errorObj);
     }
     emerg(msg, err, context) {
         const errorObj = err instanceof Error ? err : undefined;
         const combinedContext = err instanceof Error ? context : { ...(err || {}), ...(context || {}) };
-        this.log('emerg', msg, combinedContext, errorObj);
+        this.log("emerg", msg, combinedContext, errorObj);
     }
     fatal(msg, context, error) {
-        this.log('emerg', msg, context, error);
+        this.log("emerg", msg, context, error);
     }
 }
 // Export singleton instance

package/dist/utils/internal/requestContext.js

@@ -1,6 +1,6 @@
-import { logger } from './logger.js';
+import { logger } from "./logger.js";
 // Import utils from the main barrel file (generateUUID from ../security/idGenerator.js)
-import { generateUUID } from '../index.js';
+import { generateUUID } from "../index.js";
 // Direct instance for request context utilities
 const requestContextServiceInstance = {
     config: {},
@@ -12,9 +12,11 @@ const requestContextServiceInstance = {
     configure(config) {
         this.config = {
             ...this.config,
-            ...config
+            ...config,
         };
-        logger.debug('RequestContext configuration updated', { config: this.config });
+        logger.debug("RequestContext configuration updated", {
+            config: this.config,
+        });
         return { ...this.config };
     },
     /**
@@ -35,7 +37,7 @@ const requestContextServiceInstance = {
         return {
             requestId,
             timestamp,
-            ...additionalContext
+            ...additionalContext,
         };
     },
     // generateSecureRandomString function removed as it was unused and redundant

package/dist/utils/metrics/index.js

@@ -1 +1 @@
-export * from './tokenCounter.js';
+export * from "./tokenCounter.js";

package/dist/utils/metrics/tokenCounter.js

@@ -1,9 +1,9 @@
-import { encoding_for_model } from 'tiktoken';
-import { BaseErrorCode } from '../../types-global/errors.js';
+import { encoding_for_model } from "tiktoken";
+import { BaseErrorCode } from "../../types-global/errors.js";
 // Import utils from the main barrel file (ErrorHandler, logger, RequestContext from ../internal/*)
-import { ErrorHandler, logger } from '../index.js';
+import { ErrorHandler, logger } from "../index.js";
 // Define the model used specifically for token counting
-const TOKENIZATION_MODEL = 'gpt-4o'; // Note this is strictly for token counting, not the model used for inference
+const TOKENIZATION_MODEL = "gpt-4o"; // Note this is strictly for token counting, not the model used for inference
 /**
  * Calculates the number of tokens for a given text using the 'gpt-4o' tokenizer.
  * Uses ErrorHandler for consistent error management.
@@ -27,11 +27,11 @@ export async function countTokens(text, context) {
             encoding?.free(); // Ensure the encoder is freed if it was successfully created
         }
     }, {
-        operation: 'countTokens',
+        operation: "countTokens",
         context: context,
-        input: { textSample: text.substring(0, 50) + '...' }, // Log sanitized input
+        input: { textSample: text.substring(0, 50) + "..." }, // Log sanitized input
         errorCode: BaseErrorCode.INTERNAL_ERROR, // Use INTERNAL_ERROR for external lib issues
-        rethrow: true // Rethrow as McpError
+        rethrow: true, // Rethrow as McpError
         // Removed onErrorReturn as we now rethrow
     });
 }
@@ -65,13 +65,13 @@ context) {
                 // Encode role
                 num_tokens += encoding.encode(message.role).length;
                 // Encode content - handle potential null or array content (vision)
-                if (typeof message.content === 'string') {
+                if (typeof message.content === "string") {
                     num_tokens += encoding.encode(message.content).length;
                 }
                 else if (Array.isArray(message.content)) {
                     // Handle multi-part content (e.g., text + image) - simplified: encode text parts only
                     for (const part of message.content) {
-                        if (part.type === 'text') {
+                        if (part.type === "text") {
                             num_tokens += encoding.encode(part.text).length;
                         }
                         else {
@@ -83,13 +83,15 @@ context) {
                     }
                 } // else: content is null, add 0 tokens
                 // Encode name if present (often associated with 'tool' or 'function' roles in newer models)
-                if ('name' in message && message.name) {
+                if ("name" in message && message.name) {
                     num_tokens += tokens_per_name;
                     num_tokens += encoding.encode(message.name).length;
                 }
                 // --- Handle tool calls (specific to newer models) ---
                 // Assistant message requesting tool calls
-                if (message.role === 'assistant' && 'tool_calls' in message && message.tool_calls) {
+                if (message.role === "assistant" &&
+                    "tool_calls" in message &&
+                    message.tool_calls) {
                     for (const tool_call of message.tool_calls) {
                         // Add tokens for the function name and arguments
                         if (tool_call.function.name) {
@@ -102,7 +104,9 @@ context) {
                     }
                 }
                 // Tool message providing results
-                if (message.role === 'tool' && 'tool_call_id' in message && message.tool_call_id) {
+                if (message.role === "tool" &&
+                    "tool_call_id" in message &&
+                    message.tool_call_id) {
                     num_tokens += encoding.encode(message.tool_call_id).length;
                     // Content of the tool message (the result) is already handled by the string content check above
                 }
@@ -114,11 +118,11 @@ context) {
             encoding?.free();
         }
     }, {
-        operation: 'countChatTokens',
+        operation: "countChatTokens",
         context: context,
         input: { messageCount: messages.length }, // Log sanitized input
         errorCode: BaseErrorCode.INTERNAL_ERROR, // Use INTERNAL_ERROR
-        rethrow: true // Rethrow as McpError
+        rethrow: true, // Rethrow as McpError
         // Removed onErrorReturn
     });
 }