Renamed McpLogger to ClientLogger

Author: Adebayo120

README.md

@@ -236,12 +236,12 @@ Automatically inject PSR-3 compatible logger into your registered handlers:
 ```php
 // Enable logging in server
 $server = Server::builder()
-    ->enableMcpLogging()
+    ->enableClientLogging()
     ->build();
 
 // Use in any handler - logger is auto-injected
 #[McpTool]
-public function processData(string $input, McpLogger $logger): array {
+public function processData(string $input, ClientLogger $logger): array {
     $logger->info('Processing data', ['input' => $input]);
     return ['result' => 'processed'];
 }

examples/stdio-discovery-calculator/McpElements.php

@@ -13,7 +13,9 @@
 
 use Mcp\Capability\Attribute\McpResource;
 use Mcp\Capability\Attribute\McpTool;
-use Mcp\Capability\Logger\McpLogger;
+use Mcp\Capability\Logger\ClientLogger;
+use Psr\Log\LoggerInterface;
+use Psr\Log\NullLogger;
 
 /**
  * @phpstan-type Config array{precision: int, allow_negative: bool}
@@ -28,6 +30,11 @@ final class McpElements
         'allow_negative' => true,
     ];
 
+    public function __construct(
+        private readonly LoggerInterface $logger = new NullLogger(),
+    ) {
+    }
+
     /**
      * Performs a calculation based on the operation.
      *
@@ -37,19 +44,14 @@ final class McpElements
      * @param float     $a         the first operand
      * @param float     $b         the second operand
      * @param string    $operation the operation ('add', 'subtract', 'multiply', 'divide')
-     * @param McpLogger $logger    Auto-injected MCP logger
+     * @param ClientLogger $logger    Auto-injected MCP logger
      *
      * @return float|string the result of the calculation, or an error message string
      */
     #[McpTool(name: 'calculate')]
-    public function calculate(float $a, float $b, string $operation, McpLogger $logger): float|string
+    public function calculate(float $a, float $b, string $operation, ClientLogger $logger): float|string
     {
-        $logger->info('🧮 Calculate tool called', [
-            'operand_a' => $a,
-            'operand_b' => $b,
-            'operation' => $operation,
-            'auto_injection' => 'McpLogger auto-injected successfully',
-        ]);
+        $this->logger->info(\sprintf('Calculating: %f %s %f', $a, $operation, $b));
 
         $op = strtolower($operation);
 
@@ -105,7 +107,7 @@ public function calculate(float $a, float $b, string $operation, McpLogger $logg
      * Provides the current calculator configuration.
      * Can be read by clients to understand precision etc.
      *
-     * @param McpLogger $logger Auto-injected MCP logger for demonstration
+     * @param ClientLogger $logger Auto-injected MCP logger for demonstration
      *
      * @return Config the configuration array
      */
@@ -115,11 +117,11 @@ public function calculate(float $a, float $b, string $operation, McpLogger $logg
         description: 'Current settings for the calculator tool (precision, allow_negative).',
         mimeType: 'application/json',
     )]
-    public function getConfiguration(McpLogger $logger): array
+    public function getConfiguration(ClientLogger $logger): array
     {
         $logger->info('📊 Resource config://calculator/settings accessed via auto-injection!', [
             'current_config' => $this->config,
-            'auto_injection_demo' => 'McpLogger was automatically injected into this resource handler',
+            'auto_injection_demo' => 'ClientLogger was automatically injected into this resource handler',
         ]);
 
         return $this->config;
@@ -131,7 +133,7 @@ public function getConfiguration(McpLogger $logger): array
      *
      * @param string    $setting the setting key ('precision' or 'allow_negative')
      * @param mixed     $value   the new value (int for precision, bool for allow_negative)
-     * @param McpLogger $logger  Auto-injected MCP logger
+     * @param ClientLogger $logger  Auto-injected MCP logger
      *
      * @return array{
      *     success: bool,
@@ -140,14 +142,9 @@ public function getConfiguration(McpLogger $logger): array
      * } success message or error
      */
     #[McpTool(name: 'update_setting')]
-    public function updateSetting(string $setting, mixed $value, McpLogger $logger): array
+    public function updateSetting(string $setting, mixed $value, ClientLogger $logger): array
     {
-        $logger->info('🔧 Update setting tool called', [
-            'setting' => $setting,
-            'value' => $value,
-            'current_config' => $this->config,
-            'auto_injection' => 'McpLogger auto-injected successfully',
-        ]);
+        $this->logger->info(\sprintf('Setting tool called: setting=%s, value=%s', $setting, var_export($value, true)));
         if (!\array_key_exists($setting, $this->config)) {
             $logger->error('Unknown setting requested', [
                 'setting' => $setting,

examples/stdio-discovery-calculator/server.php

@@ -23,7 +23,7 @@
     ->setInstructions('This server supports basic arithmetic operations: add, subtract, multiply, and divide. Send JSON-RPC requests to perform calculations.')
     ->setContainer(container())
     ->setLogger(logger())
-    ->enableMcpLogging()  // Enable MCP logging capability and auto-injection!
+    ->enableClientLogging()  // Enable Client logging capability and auto-injection!
     ->setDiscovery(__DIR__, ['.'])
     ->build();
 

examples/stdio-logging-showcase/LoggingShowcaseHandlers.php

@@ -12,27 +12,27 @@
 namespace Mcp\Example\StdioLoggingShowcase;
 
 use Mcp\Capability\Attribute\McpTool;
-use Mcp\Capability\Logger\McpLogger;
+use Mcp\Capability\Logger\ClientLogger;
 
 /**
  * Example handlers showcasing auto-injected MCP logging capabilities.
  *
- * This demonstrates how handlers can receive McpLogger automatically
+ * This demonstrates how handlers can receive ClientLogger automatically
  * without any manual configuration - just declare it as a parameter!
  */
 final class LoggingShowcaseHandlers
 {
     /**
-     * Tool that demonstrates different logging levels with auto-injected McpLogger.
+     * Tool that demonstrates different logging levels with auto-injected ClientLogger.
      *
      * @param string    $message The message to log
      * @param string    $level   The logging level (debug, info, warning, error)
-     * @param McpLogger $logger  Auto-injected MCP logger
+     * @param ClientLogger $logger  Auto-injected MCP logger
      *
      * @return array<string, mixed>
      */
     #[McpTool(name: 'log_message', description: 'Demonstrates MCP logging with different levels')]
-    public function logMessage(string $message, string $level, McpLogger $logger): array
+    public function logMessage(string $message, string $level, ClientLogger $logger): array
     {
         $logger->info('🚀 Starting log_message tool', [
             'requested_level' => $level,

examples/stdio-logging-showcase/server.php

@@ -23,7 +23,7 @@
     ->setServerInfo('Stdio Logging Showcase', '1.0.0', 'Demonstration of auto-injected MCP logging in capability handlers.')
     ->setContainer(container())
     ->setLogger(logger())
-    ->enableMcpLogging()  // Enable MCP logging capability and auto-injection!
+    ->enableClientLogging()  // Enable MCP logging capability and auto-injection!
     ->setDiscovery(__DIR__, ['.'])
     ->build();
 
@@ -32,4 +32,4 @@
 $server->run($transport);
 
 logger()->info('Logging Showcase Server is ready!');
-logger()->info('This example demonstrates auto-injection of McpLogger into capability handlers.');
+logger()->info('This example demonstrates auto-injection of ClientLogger into capability handlers.');

src/Capability/Discovery/SchemaGenerator.php

@@ -792,7 +792,7 @@ private function mapSimpleTypeToJsonSchema(string $type): string
     /**
      * Determines if a parameter was auto-injected and should be excluded from schema generation.
      *
-     * Parameters that are auto-injected by the framework (like McpLogger) should not appear
+     * Parameters that are auto-injected by the framework (like ClientLogger) should not appear
      * in the tool schema since they're not provided by the client.
      */
     private function isAutoInjectedParameter(\ReflectionParameter $parameter): bool
@@ -805,8 +805,8 @@ private function isAutoInjectedParameter(\ReflectionParameter $parameter): bool
 
         $typeName = $type->getName();
 
-        // Auto-inject for McpLogger or LoggerInterface types
-        return 'Mcp\\Capability\\Logger\\McpLogger' === $typeName 
+        // Auto-inject for ClientLogger or LoggerInterface types
+        return 'Mcp\\Capability\\Logger\\ClientLogger' === $typeName 
             || 'Psr\\Log\\LoggerInterface' === $typeName;
     }
 }

src/Capability/Logger/McpLogger.php renamed to src/Capability/Logger/ClientLogger.php

@@ -25,7 +25,7 @@
  *
  * @author Adam Jamiu <[email protected]>
  */
-final class McpLogger extends AbstractLogger
+final class ClientLogger extends AbstractLogger
 {
     public function __construct(
         private readonly NotificationSender $notificationSender,

src/Capability/Registry/ReferenceHandler.php

@@ -11,7 +11,7 @@
 
 namespace Mcp\Capability\Registry;
 
-use Mcp\Capability\Logger\McpLogger;
+use Mcp\Capability\Logger\ClientLogger;
 use Mcp\Exception\InvalidArgumentException;
 use Mcp\Exception\RegistryException;
 use Psr\Container\ContainerInterface;
@@ -23,7 +23,7 @@ final class ReferenceHandler implements ReferenceHandlerInterface
 {
     public function __construct(
         private readonly ?ContainerInterface $container = null,
-        private readonly ?McpLogger $mcpLogger = null,
+        private readonly ?ClientLogger $clientLogger = null,
     ) {
     }
 
@@ -91,16 +91,16 @@ private function prepareArguments(\ReflectionFunctionAbstract $reflection, array
             $paramName = $parameter->getName();
             $paramPosition = $parameter->getPosition();
 
-            // Auto-inject McpLogger if parameter expects it
-            if ($this->shouldInjectMcpLogger($parameter)) {
-                if (null !== $this->mcpLogger) {
-                    $finalArgs[$paramPosition] = $this->mcpLogger;
+            // Auto-inject ClientLogger if parameter expects it
+            if ($this->shouldInjectClientLogger($parameter)) {
+                if (null !== $this->clientLogger) {
+                    $finalArgs[$paramPosition] = $this->clientLogger;
                     continue;
                 } elseif ($parameter->allowsNull() || $parameter->isOptional()) {
                     $finalArgs[$paramPosition] = null;
                     continue;
                 }
-                // If McpLogger is required but not available, fall through to normal handling
+                // If ClientLogger is required but not available, fall through to normal handling
             }
 
             if (isset($arguments[$paramName])) {
@@ -130,9 +130,9 @@ private function prepareArguments(\ReflectionFunctionAbstract $reflection, array
     }
 
     /**
-     * Determines if the parameter should receive auto-injected McpLogger.
+     * Determines if the parameter should receive auto-injected ClientLogger.
      */
-    private function shouldInjectMcpLogger(\ReflectionParameter $parameter): bool
+    private function shouldInjectClientLogger(\ReflectionParameter $parameter): bool
     {
         $type = $parameter->getType();
 
@@ -142,8 +142,8 @@ private function shouldInjectMcpLogger(\ReflectionParameter $parameter): bool
 
         $typeName = $type->getName();
 
-        // Auto-inject for McpLogger or LoggerInterface types
-        return McpLogger::class === $typeName || \Psr\Log\LoggerInterface::class === $typeName;
+        // Auto-inject for ClientLogger or LoggerInterface types
+        return ClientLogger::class === $typeName || \Psr\Log\LoggerInterface::class === $typeName;
     }
 
     /**

src/Server/Builder.php

@@ -20,7 +20,7 @@
 use Mcp\Capability\Discovery\DocBlockParser;
 use Mcp\Capability\Discovery\HandlerResolver;
 use Mcp\Capability\Discovery\SchemaGenerator;
-use Mcp\Capability\Logger\McpLogger;
+use Mcp\Capability\Logger\ClientLogger;
 use Mcp\Capability\Registry;
 use Mcp\Capability\Registry\Container;
 use Mcp\Capability\Registry\ElementReference;
@@ -241,13 +241,13 @@ public function addNotificationHandlers(iterable $handlers): self
     }
 
     /**
-     * Enables MCP logging capability for the server.
+     * Enables Client logging capability for the server.
      *
      * When enabled, the server will advertise logging capability to clients,
      * indicating that it can emit structured log messages according to the MCP specification.
-     * This enables auto-injection of McpLogger into capability handlers.
+     * This enables auto-injection of ClientLogger into capability handlers.
      */
-    public function enableMcpLogging(): self
+    public function enableClientLogging(): self
     {
         $this->loggingMessageNotificationEnabled = true;
 
@@ -421,9 +421,9 @@ public function build(): Server
         $notificationHandler = NotificationHandler::make($registry, $logger);
         $notificationSender = new NotificationSender($notificationHandler, null, $logger);
 
-        // Create McpLogger for components that should send logs via MCP
-        $mcpLogger = new McpLogger($notificationSender, $logger);
-        $referenceHandler = new ReferenceHandler($container, $mcpLogger);
+        // Create ClientLogger for components that should send logs via MCP
+        $clientLogger = new ClientLogger($notificationSender, $logger);
+        $referenceHandler = new ReferenceHandler($container, $clientLogger);
 
         $requestHandlers = array_merge($this->requestHandlers, [
             new Handler\Request\PingHandler(),
@@ -448,6 +448,7 @@ public function build(): Server
             messageFactory: $messageFactory,
             sessionFactory: $sessionFactory,
             sessionStore: $sessionStore,
+            logger: $logger,
         );
 
         return new Server($protocol, $notificationSender, $logger);

tests/Unit/Capability/Discovery/SchemaGeneratorFixture.php

@@ -414,12 +414,12 @@ public function parameterSchemaInferredType(
     }
 
     /**
-     * Method with McpLogger that should be excluded from schema.
+     * Method with ClientLogger that should be excluded from schema.
      *
      * @param string $message The message to process
-     * @param \Mcp\Capability\Logger\McpLogger $logger Auto-injected logger
+     * @param \Mcp\Capability\Logger\ClientLogger $logger Auto-injected logger
      */
-    public function withMcpLogger(string $message, \Mcp\Capability\Logger\McpLogger $logger): string
+    public function withClientLogger(string $message, \Mcp\Capability\Logger\ClientLogger $logger): string
     {
         return $message;
     }