opik-mcp 0.1.3 → 2.0.1

package/README.md

@@ -1,20 +1,19 @@
 <h1 align="center" style="border-bottom: none">
-    <div>
-        <a href="https://www.comet.com/site/products/opik/?from=llm&utm_source=opik&utm_medium=github&utm_content=header_img&utm_campaign=opik-mcp">
-            <picture>
-                <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/comet-ml/opik-mcp/refs/heads/main/docs/assets/logo-dark-mode.svg">
-                <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/comet-ml/opik-mcp/refs/heads/main/docs/assets/logo-light-mode.svg">
-                <img alt="Comet Opik logo" src="docs/assets/logo-light-mode.svg" width="200" />
-            </picture>
-        </a>
-        <br>
-        Opik MCP Server
-    </div>
-    (Model Context Protocol)<br>
+  <div>
+    <a href="https://www.comet.com/site/products/opik/?from=llm&utm_source=opik&utm_medium=github&utm_content=header_img&utm_campaign=opik-mcp">
+      <picture>
+        <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/comet-ml/opik-mcp/refs/heads/main/docs/assets/logo-dark-mode.svg">
+        <source media="(prefers-color-scheme: light)" srcset="https://raw.githubusercontent.com/comet-ml/opik-mcp/refs/heads/main/docs/assets/logo-light-mode.svg">
+        <img alt="Comet Opik logo" src="docs/assets/logo-light-mode.svg" width="200" />
+      </picture>
+    </a>
+    <br />
+    Opik MCP Server
+  </div>
 </h1>
 
 <p align="center">
-A Model Context Protocol (MCP) implementation for the <a href="https://github.com/comet-ml/opik/">Opik platform</a> with support for multiple transport mechanisms, enabling seamless integration with IDEs and providing a unified interface for Opik's capabilities.
+Model Context Protocol (MCP) server for <a href="https://github.com/comet-ml/opik/">Opik</a>, with both local stdio and remote streamable-http transports.
 </p>
 
 <div align="center">
@@ -22,198 +21,202 @@ A Model Context Protocol (MCP) implementation for the <a href="https://github.co
 [![License](https://img.shields.io/github/license/comet-ml/opik-mcp)](https://github.com/comet-ml/opik-mcp/blob/main/LICENSE)
 [![Node.js Version](https://img.shields.io/badge/node-%3E%3D20.11.0-brightgreen)](https://nodejs.org/)
 [![TypeScript](https://img.shields.io/badge/typescript-%5E5.8.2-blue)](https://www.typescriptlang.org/)
-<img src="https://badge.mcpx.dev?status=on" title="MCP Enabled"/>
-[![DOI](https://zenodo.org/badge/DOI/10.5281/zenodo.15411156.svg)](https://doi.org/10.5281/zenodo.15411156)
+<a href="https://www.comet.com/docs/opik/prompt_engineering/mcp_server"><img src="https://badge.mcpx.dev?status=on" title="MCP Enabled" alt="MCP Enabled" /></a>
+<a href="https://doi.org/10.5281/zenodo.15411156"><img src="https://zenodo.org/badge/DOI/10.5281/zenodo.15411156.svg" alt="DOI" /></a>
 
 </div>
 
 <p align="center">
-    <a href="https://www.comet.com/site/products/opik/?from=llm&utm_source=opik&utm_medium=github&utm_content=website_button&utm_campaign=opik"><b>Website</b></a> •
-    <a href="https://chat.comet.com"><b>Slack community</b></a> •
-    <a href="https://x.com/Cometml"><b>Twitter</b></a> •
-    <a href="https://www.comet.com/docs/opik/?from=llm&utm_source=opik&utm_medium=github&utm_content=docs_button&utm_campaign=opik"><b>Documentation</b></a>
-</p>
-
-<p align="center">
-    <a href="https://glama.ai/mcp/servers/@comet-ml/opik-mcp" rel="nofollow" target="_blank">
-      <img width="380" height="200" src="https://glama.ai/mcp/servers/@comet-ml/opik-mcp/badge" alt="Opik Server MCP server" />
-    </a>
+  <a href="https://www.comet.com/site/products/opik/?from=llm&utm_source=opik&utm_medium=github&utm_content=website_button&utm_campaign=opik"><b>Website</b></a> •
+  <a href="https://chat.comet.com"><b>Slack community</b></a> •
+  <a href="https://x.com/Cometml"><b>Twitter</b></a> •
+  <a href="https://www.comet.com/docs/opik/?from=llm&utm_source=opik&utm_medium=github&utm_content=docs_button&utm_campaign=opik"><b>Documentation</b></a>
 </p>
 
-> **⚠️ Notice:** SSE (Server-Sent Events) transport support is currently experimental and untested. For production use, we recommend using the direct process execution approach shown in the IDE integration examples.
-
-## 🚀 What is Opik MCP Server?
+> [!IMPORTANT]
+> This repository ships the MCP server implementation only. We do not currently provide a hosted remote MCP service for Opik.
+> If you run `streamable-http` remotely, authentication is fail-closed by default.
 
-Opik MCP Server is an open-source implementation of the Model Context Protocol for the Opik platform. It provides a unified interface for interacting with Opik's capabilities, supporting multiple transport mechanisms for flexible integration into various environments.
+## Why this server
 
-<br>
+Opik MCP Server gives MCP-compatible clients one interface for:
 
-You can use Opik MCP Server for:
-* **IDE Integration:**
-  * Seamlessly integrate with Cursor and other compatible IDEs
-  * Provide direct access to Opik's capabilities from your development environment
+- Prompt lifecycle management
+- Workspace, project, and trace exploration
+- Metrics and dataset operations
+- MCP resources and resource templates for metadata-aware flows
 
-* **Unified API Access:**
-  * Access all Opik features through a standardized protocol
-  * Leverage multiple transport options (stdio, SSE) for different integration scenarios
+## Quickstart
 
-* **Platform Management:**
-  * Manage prompts, projects, traces, and metrics through a consistent interface
-  * Organize and monitor your LLM applications efficiently
+### 1. Run with npx
 
-## Features
-
-- **Prompts Management**: Create, list, update, and delete prompts
-- **Projects/Workspaces Management**: Organize and manage projects
-- **Traces**: Track and analyze trace data
-- **Metrics**: Gather and query metrics data
-
-## Quick Start
-
-### Installation
-
-#### Cursor Integration
+```bash
+# Opik Cloud
+npx -y opik-mcp --apiKey YOUR_API_KEY
+```
 
-To integrate with Cursor IDE, open to the Cursor settings page and navigate
-to the Features tab. If you scroll down to the MCP section you will see the
-button `+ Add new MCP server` that will allow you to add the Opik MCP server.
+For self-hosted Opik, pass `--apiUrl` (for example `http://localhost:5173/api`) and use your local auth strategy.
 
-Once the `New MCP server` modal is open, select `command` as the server type and
-enter the command: `npx -y opik-mcp --apiKey YOUR_API_KEY`.
+### 2. Add to your MCP client
 
-Alternatively, you can create a `.cursor/mcp.json` in your project and add:
+Cursor (`.cursor/mcp.json`):
 
 ```json
 {
   "mcpServers": {
     "opik": {
       "command": "npx",
-      "args": [
-        "-y",
-        "opik-mcp",
-        "--apiKey",
-        "YOUR_API_KEY"
-      ]
+      "args": ["-y", "opik-mcp", "--apiKey", "YOUR_API_KEY"]
     }
   }
 }
 ```
 
-Note: If you are using the Open-Source version of Opik, you will need to specify
-the `apiBaseUrl` parameter as `http://localhost:5173/api`.
+VS Code / GitHub Copilot (`.vscode/mcp.json`):
 
-#### Windsurf Installation
+```json
+{
+  "inputs": [
+    {
+      "type": "promptString",
+      "id": "opik-api-key",
+      "description": "Opik API Key",
+      "password": true
+    }
+  ],
+  "servers": {
+    "opik-mcp": {
+      "type": "stdio",
+      "command": "npx",
+      "args": ["-y", "opik-mcp", "--apiKey", "${input:opik-api-key}"]
+    }
+  }
+}
+```
 
-To install the MCP server in Windsurf, you will need to open the Windsurf settings
-and navigate to the MCP section. From there, click on `View raw config` and update
-the configuration object to be:
+Windsurf (raw config):
 
 ```json
 {
-    "mcpServers": {
-      "opik": {
-        "command": "npx",
-        "args": [
-          "-y",
-          "opik-mcp",
-          "--apiKey",
-          "YOUR_API_KEY"
-        ]
-      }
+  "mcpServers": {
+    "opik": {
+      "command": "npx",
+      "args": ["-y", "opik-mcp", "--apiKey", "YOUR_API_KEY"]
     }
   }
+}
 ```
 
-Note: If you are using the Open-Source version of Opik, you will need to specify
-the `apiBaseUrl` parameter as `http://localhost:5173/api`.
+More client-specific examples: [docs/ide-integration.md](docs/ide-integration.md)
+
+## Run from source
 
-#### Manual Installation
 ```bash
-# Clone the repository
 git clone https://github.com/comet-ml/opik-mcp.git
 cd opik-mcp
-
-# Install dependencies and build
 npm install
 npm run build
 ```
 
-**Configuration**
-
-Create a `.env` file based on the example:
+Optional local config:
 
 ```bash
 cp .env.example .env
-# Edit .env with your specific configuration
 ```
 
-**Starting the Server**
+Start the server:
 
 ```bash
-# Start with stdio transport (default)
 npm run start:stdio
-
-# Start with SSE transport for network access (experimental)
-npm run start:sse
+npm run start:http
 ```
 
-## Transport Options
+## Transport modes
 
-### Standard Input/Output
+| Transport | Use case | Command |
+| --- | --- | --- |
+| `stdio` | Local MCP integration (same machine as client) | `npm run start:stdio` |
+| `streamable-http` | Remote/self-hosted MCP endpoint (`/mcp`) | `npm run start:http` |
 
-Ideal for local integration where the client and server run on the same machine.
+### Remote auth defaults (`streamable-http`)
 
-```bash
-make start-stdio
-```
+- `Authorization: Bearer <OPIK_API_KEY>` or `x-api-key` is required by default.
+- Workspace is resolved server-side (token map recommended); workspace headers are not trusted by default.
+- In remote mode, request-context workspace takes precedence over tool `workspaceName`.
+- Missing or invalid auth returns HTTP `401`.
 
-### Server-Sent Events (SSE)
+Key environment flags:
 
-Enables remote access and multiple simultaneous clients over HTTP. Note that this transport option is experimental.
+- `STREAMABLE_HTTP_REQUIRE_AUTH` (default `true`)
+- `STREAMABLE_HTTP_VALIDATE_REMOTE_AUTH` (default `true`, except test env)
+- `REMOTE_TOKEN_WORKSPACE_MAP` (JSON token-to-workspace map)
+- `STREAMABLE_HTTP_TRUST_WORKSPACE_HEADERS` (default `false`)
 
-```bash
-make start-sse
-```
+Deep dive: [docs/streamable-http-transport.md](docs/streamable-http-transport.md)
 
-For detailed information about the SSE transport, see [docs/sse-transport.md](docs/sse-transport.md).
+## Toolsets
 
-## Development
+Toolsets let you narrow which capabilities are enabled:
 
-### Testing
+- `core`
+- `integration`
+- `expert-prompts`
+- `expert-datasets`
+- `expert-trace-actions`
+- `expert-project-actions`
+- `metrics`
+- `all` (enables all modern toolsets)
 
-```bash
-# Run all tests
-npm test
+Configure via:
 
-# Run specific test suite
-npm test -- tests/transports/sse-transport.test.ts
-```
+- CLI: `--toolsets all`
+- Env: `OPIK_TOOLSETS=core,expert-prompts,metrics`
+
+Details: [docs/configuration.md](docs/configuration.md)
+
+## MCP resources and prompts
 
-### Pre-commit Hooks
+- `resources/list` exposes static URIs (for example `opik://workspace-info`)
+- `resources/templates/list` exposes dynamic URI templates (for example `opik://projects/{page}/{size}`)
+- `resources/read` supports static and templated URIs
+- `prompts/list` and `prompts/get` expose workflow prompts
 
-This project uses pre-commit hooks to ensure code quality:
+## Development
 
 ```bash
-# Run pre-commit checks manually
+# Lint
+npm run lint
+
+# Test
+npm test
+
+# Build
+npm run build
+
+# Run precommit checks
 make precommit
 ```
 
 ## Documentation
 
-- [SSE Transport](docs/sse-transport.md) - Details on using the SSE transport
-- [API Reference](docs/api-reference.md) - Complete API documentation
-- [Configuration](docs/configuration.md) - Advanced configuration options
-- [IDE Integration](docs/ide-integration.md) - Integration with Cursor IDE
+- [API Reference](docs/api-reference.md)
+- [Configuration](docs/configuration.md)
+- [IDE Integration](docs/ide-integration.md)
+- [Streamable HTTP Transport](docs/streamable-http-transport.md)
+
+## Contributing
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) before opening a PR.
 
 ## Citation
 
-If you use this project in your research, please cite it as follows:
+If you use this project in research, cite:
 
 ```
 Comet ML, Inc, Koc, V., & Boiko, Y. (2025). Opik MCP Server. Github. https://doi.org/10.5281/zenodo.15411156
 ```
 
-Or use the following BibTeX entry:
+BibTeX:
 
 ```bibtex
 @software{CometML_Opik_MCP_Server_2025,
@@ -226,7 +229,7 @@ Or use the following BibTeX entry:
 }
 ```
 
-You can also find citation information in the `CITATION.cff` file in this repository.
+Citation metadata is also available in [CITATION.cff](CITATION.cff).
 
 ## License
 

package/build/cli.js

@@ -2,31 +2,44 @@
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import configImport from './config.js';
+import { main } from './index.js';
 // Parse command line arguments
 const argv = yargs(hideBin(process.argv))
     .scriptName('opik-mcp')
     .usage('$0 [args]')
     .option('transport', {
     alias: 't',
-    description: 'Transport to use (stdio or sse)',
+    description: 'Transport to use (stdio or streamable-http)',
     type: 'string',
-    default: 'stdio',
-    choices: ['stdio', 'sse'],
+    choices: ['stdio', 'streamable-http'],
 })
     .option('port', {
     alias: 'p',
-    description: 'Port to listen on (for sse transport)',
+    description: 'Port to listen on (for streamable-http transport)',
     type: 'number',
-    default: 3001,
 })
     .help()
     .alias('help', 'h')
     .strict(false) // Allow unknown options
     .parseSync();
 // Update config based on CLI arguments
-configImport.transport = argv.transport;
-if (argv.transport === 'sse') {
-    configImport.ssePort = argv.port;
+if (argv.transport) {
+    configImport.transport = argv.transport;
+    process.env.TRANSPORT = argv.transport;
 }
-// Import and start the server (index.js will handle the main() call)
-import './index.js';
+if (argv.transport === 'streamable-http' && typeof argv.port === 'number') {
+    configImport.streamableHttpPort = argv.port;
+    process.env.STREAMABLE_HTTP_PORT = String(argv.port);
+}
+function toErrorMessage(error) {
+    if (error instanceof Error) {
+        return error.message;
+    }
+    return String(error);
+}
+// Start the server after applying CLI overrides.
+main().catch((error) => {
+    const message = toErrorMessage(error);
+    console.error(`Failed to start Opik MCP server: ${message}`);
+    process.exit(1);
+});

package/build/config.js

@@ -31,7 +31,76 @@ function writeToLogFile(message, forceWrite = false) {
         // Silently fail if we can't write to the log file
     }
 }
-export const DEFAULT_TOOLSETS = ['integration', 'prompts', 'projects', 'traces'];
+export const DEFAULT_TOOLSETS = ['core'];
+export const ALL_TOOLSETS = [
+    'core',
+    'expert-prompts',
+    'expert-datasets',
+    'expert-trace-actions',
+    'expert-project-actions',
+    'integration',
+    'metrics',
+];
+const ALL_TOOLSET_CHOICES = [
+    'all',
+    'core',
+    'expert-prompts',
+    'expert-datasets',
+    'expert-trace-actions',
+    'expert-project-actions',
+    'integration',
+    'metrics',
+    'capabilities',
+    'prompts',
+    'datasets',
+    'projects',
+    'traces',
+];
+export function normalizeToolsets(values) {
+    const normalized = new Set();
+    for (const value of values
+        .flatMap((v) => v.split(','))
+        .map((v) => v.trim())) {
+        const toolset = value;
+        switch (toolset) {
+            case 'all':
+                for (const item of ALL_TOOLSETS) {
+                    normalized.add(item);
+                }
+                break;
+            case 'core':
+            case 'expert-prompts':
+            case 'expert-datasets':
+            case 'expert-trace-actions':
+            case 'expert-project-actions':
+            case 'integration':
+            case 'metrics':
+                normalized.add(toolset);
+                break;
+            // Legacy aliases
+            case 'capabilities':
+                normalized.add('core');
+                break;
+            case 'prompts':
+                normalized.add('expert-prompts');
+                break;
+            case 'datasets':
+                normalized.add('expert-datasets');
+                break;
+            case 'projects':
+                normalized.add('core');
+                normalized.add('expert-project-actions');
+                break;
+            case 'traces':
+                normalized.add('core');
+                normalized.add('expert-trace-actions');
+                break;
+            default:
+                break;
+        }
+    }
+    return Array.from(normalized);
+}
 /**
  * Load configuration from ~/.opik.config file
  */
@@ -49,7 +118,9 @@ function loadOpikConfigFile() {
         for (const line of lines) {
             const trimmedLine = line.trim();
             // Skip empty lines and comments
-            if (!trimmedLine || trimmedLine.startsWith('#') || trimmedLine.startsWith(';')) {
+            if (!trimmedLine ||
+                trimmedLine.startsWith('#') ||
+                trimmedLine.startsWith(';')) {
                 continue;
             }
             // Check for section headers
@@ -78,7 +149,7 @@ function loadOpikConfigFile() {
                 }
             }
         }
-        writeToLogFile(`Loaded config from ~/.opik.config: ${JSON.stringify(config)}`);
+        writeToLogFile(`Loaded config from ~/.opik.config with keys: ${Object.keys(config).join(', ') || '(none)'}`);
         return config;
     }
     catch (error) {
@@ -118,24 +189,20 @@ function parseCommandLineArgs() {
         // Transport Configuration
         .option('transport', {
         type: 'string',
-        description: 'Transport type (stdio or sse)',
-        choices: ['stdio', 'sse'],
-        default: 'stdio',
+        description: 'Transport type (stdio or streamable-http)',
+        choices: ['stdio', 'streamable-http'],
     })
-        .option('ssePort', {
+        .option('streamableHttpPort', {
         type: 'number',
-        description: 'Port for SSE transport',
-        default: 3001,
+        description: 'Port for streamable-http transport',
     })
-        .option('sseHost', {
+        .option('streamableHttpHost', {
         type: 'string',
-        description: 'Host for SSE transport',
-        default: 'localhost',
+        description: 'Host for streamable-http transport',
     })
-        .option('sseLogPath', {
+        .option('streamableHttpLogPath', {
         type: 'string',
-        description: 'Log file path for SSE transport',
-        default: '/tmp/opik-mcp-sse.log',
+        description: 'Log file path for streamable-http transport',
     })
         // MCP Configuration
         .option('mcpName', {
@@ -162,7 +229,7 @@ function parseCommandLineArgs() {
         .option('toolsets', {
         type: 'array',
         description: 'Comma-separated list of toolsets to enable',
-        choices: ['capabilities', 'integration', 'prompts', 'projects', 'traces', 'metrics'],
+        choices: ALL_TOOLSET_CHOICES,
     })
         .help()
         .parse();
@@ -190,28 +257,41 @@ export function loadConfig() {
         isSelfHosted: args.selfHosted !== undefined
             ? args.selfHosted
             : process.env.OPIK_SELF_HOSTED === 'true' || false,
-        debugMode: args.debug !== undefined ? args.debug : process.env.DEBUG_MODE === 'true' || false,
+        debugMode: args.debug !== undefined
+            ? args.debug
+            : process.env.DEBUG_MODE === 'true' || false,
         // Transport configuration
-        transport: (args.transport || process.env.TRANSPORT || 'stdio'),
-        ssePort: args.ssePort || (process.env.SSE_PORT ? parseInt(process.env.SSE_PORT, 10) : 3001),
-        sseHost: args.sseHost || process.env.SSE_HOST || 'localhost',
-        sseLogPath: args.sseLogPath || process.env.SSE_LOG_PATH || '/tmp/opik-mcp-sse.log',
+        transport: (args.transport ?? process.env.TRANSPORT ?? 'stdio'),
+        streamableHttpPort: args.streamableHttpPort ??
+            (process.env.STREAMABLE_HTTP_PORT
+                ? parseInt(process.env.STREAMABLE_HTTP_PORT, 10)
+                : 3001),
+        streamableHttpHost: args.streamableHttpHost ??
+            process.env.STREAMABLE_HTTP_HOST ??
+            '127.0.0.1',
+        streamableHttpLogPath: args.streamableHttpLogPath ??
+            (process.env.STREAMABLE_HTTP_LOG_PATH ||
+                '/tmp/opik-mcp-streamable-http.log'),
         // MCP configuration with fallbacks
         mcpName: args.mcpName || process.env.MCP_NAME || 'opik-manager',
-        mcpVersion: args.mcpVersion || process.env.MCP_VERSION || '1.0.0',
-        mcpPort: args.mcpPort || (process.env.MCP_PORT ? parseInt(process.env.MCP_PORT, 10) : undefined),
-        mcpLogging: args.mcpLogging !== undefined ? args.mcpLogging : process.env.MCP_LOGGING === 'true' || false,
-        mcpDefaultWorkspace: args.mcpDefaultWorkspace || process.env.MCP_DEFAULT_WORKSPACE || 'default',
+        mcpVersion: args.mcpVersion || process.env.MCP_VERSION || '2.0.0',
+        mcpPort: args.mcpPort ||
+            (process.env.MCP_PORT ? parseInt(process.env.MCP_PORT, 10) : undefined),
+        mcpLogging: args.mcpLogging !== undefined
+            ? args.mcpLogging
+            : process.env.MCP_LOGGING === 'true' || false,
+        mcpDefaultWorkspace: args.mcpDefaultWorkspace ||
+            process.env.MCP_DEFAULT_WORKSPACE ||
+            'default',
         // Toolset configuration with fallbacks
         enabledToolsets: (() => {
             // Command line takes precedence
             if (args.toolsets && args.toolsets.length > 0) {
-                return args.toolsets.filter((t) => ['integration', 'prompts', 'projects', 'traces', 'metrics'].includes(t));
+                return normalizeToolsets(args.toolsets);
             }
             // Environment variable fallback
             if (process.env.OPIK_TOOLSETS) {
-                const envToolsets = process.env.OPIK_TOOLSETS.split(',').map(t => t.trim());
-                return envToolsets.filter((t) => ['integration', 'prompts', 'projects', 'traces', 'metrics'].includes(t));
+                return normalizeToolsets(process.env.OPIK_TOOLSETS.split(','));
             }
             // Default toolsets
             return DEFAULT_TOOLSETS;
@@ -244,10 +324,10 @@ export function loadConfig() {
         // Log transport configuration
         writeToLogFile('\nTransport Configuration:');
         writeToLogFile(`- Transport: ${config.transport}`);
-        if (config.transport === 'sse') {
-            writeToLogFile(`- SSE Port: ${config.ssePort}`);
-            writeToLogFile(`- SSE Host: ${config.sseHost}`);
-            writeToLogFile(`- SSE Log Path: ${config.sseLogPath}`);
+        if (config.transport === 'streamable-http') {
+            writeToLogFile(`- Streamable HTTP Port: ${config.streamableHttpPort}`);
+            writeToLogFile(`- Streamable HTTP Host: ${config.streamableHttpHost}`);
+            writeToLogFile(`- Streamable HTTP Log Path: ${config.streamableHttpLogPath}`);
         }
         // Log MCP configuration
         writeToLogFile('\nMCP Configuration:');

package/build/debug-log.js

@@ -21,8 +21,8 @@ export function initDebugLog() {
     // Log environment variables
     logDebug('Environment Variables:');
     Object.keys(process.env)
-        .filter(key => key.startsWith('OPIK_'))
-        .forEach(key => {
+        .filter((key) => key.startsWith('OPIK_'))
+        .forEach((key) => {
         let value = process.env[key];
         // Mask sensitive information
         if (key === 'OPIK_API_KEY')
@@ -35,7 +35,7 @@ export function initDebugLog() {
         logDebug(`  ${index}: ${arg}`);
     });
     // Set up uncaught exception handler
-    process.on('uncaughtException', error => {
+    process.on('uncaughtException', (error) => {
         logDebug(`UNCAUGHT EXCEPTION: ${error.message}`);
         logDebug(error.stack || 'No stack trace available');
     });
@@ -44,7 +44,7 @@ export function initDebugLog() {
         logDebug(`UNHANDLED REJECTION: ${reason}`);
     });
     // Set up exit handler
-    process.on('exit', code => {
+    process.on('exit', (code) => {
         logDebug(`Process exiting with code: ${code}`);
     });
 }
@@ -52,7 +52,7 @@ export function logDebug(message) {
     const logPath = '/tmp/opik-mcp-debug.log';
     const timestamp = new Date().toISOString();
     const logMessage = `[${timestamp}] ${message}\n`;
-    return new Promise(resolve => {
+    return new Promise((resolve) => {
         try {
             fs.appendFileSync(logPath, logMessage);
         }