@juspay/neurolink 9.14.0 → 9.16.0

package/dist/lib/utils/providerRetry.js

@@ -0,0 +1,114 @@
+/**
+ * Provider-level retry utility for AI SDK calls (NL11)
+ *
+ * The Vercel AI SDK's `generateText()` and `streamText()` have built-in retry
+ * logic (`_retryWithExponentialBackoff()` with default `maxRetries: 2`) that
+ * retries on HTTP 429/500/503. These retries are completely invisible to OTel
+ * because they happen inside the AI SDK.
+ *
+ * This module provides an instrumented retry wrapper that:
+ * 1. Disables the AI SDK's internal retries (via `maxRetries: 0`)
+ * 2. Implements our own retry loop with full OTel span events
+ * 3. Records retry attempts, delays, status codes, and total attempt count
+ *
+ * @module utils/providerRetry
+ */
+import {} from "@opentelemetry/api";
+import { APICallError } from "@ai-sdk/provider";
+import { logger } from "./logger.js";
+/** Maximum number of retry attempts after the initial call (total = 1 + MAX_PROVIDER_RETRIES). */
+export const MAX_PROVIDER_RETRIES = 2;
+/** Base delay in ms for exponential backoff between retries. */
+export const BASE_RETRY_DELAY_MS = 1000;
+/**
+ * Check whether an error thrown by the AI SDK is retryable.
+ *
+ * Uses `APICallError.isInstance()` for proper type-safe detection (the class
+ * uses a branded symbol marker, so `instanceof` doesn't work across package
+ * boundaries). Falls back to duck-typing for non-APICallError cases.
+ */
+export function isRetryableProviderError(error) {
+    // Preferred path: use the AI SDK's own branded type check + isRetryable flag
+    if (APICallError.isInstance(error)) {
+        return error.isRetryable;
+    }
+    // Fallback: duck-type for status codes on errors that aren't APICallError
+    if (error && typeof error === "object" && "statusCode" in error) {
+        const statusCode = error.statusCode;
+        return statusCode === 429 || statusCode >= 500;
+    }
+    return false;
+}
+/**
+ * Extract the HTTP status code from an AI SDK error, if available.
+ */
+export function getErrorStatusCode(error) {
+    if (APICallError.isInstance(error)) {
+        return error.statusCode;
+    }
+    if (error && typeof error === "object" && "statusCode" in error) {
+        return error.statusCode;
+    }
+    return undefined;
+}
+/**
+ * Execute a provider call with instrumented retry logic.
+ *
+ * @param operation  - The async operation to execute (should already use `maxRetries: 0`)
+ * @param span       - The OTel span to annotate with retry events and attributes
+ * @param label      - A human-readable label for log messages (e.g. "generateText", "streamText")
+ * @returns The result of the operation
+ */
+export async function withProviderRetry(operation, span, label) {
+    for (let attempt = 0; attempt <= MAX_PROVIDER_RETRIES; attempt++) {
+        try {
+            const result = await operation();
+            // Record how many attempts it took on the span
+            span.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
+            if (attempt > 0) {
+                logger.info(`[providerRetry] ${label} succeeded after ${attempt + 1} attempts`);
+            }
+            return result;
+        }
+        catch (error) {
+            const retryable = isRetryableProviderError(error);
+            const statusCode = getErrorStatusCode(error);
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            if (!retryable || attempt === MAX_PROVIDER_RETRIES) {
+                // Record failure details before re-throwing
+                span.setAttribute("gen_ai.provider.total_attempts", attempt + 1);
+                if (attempt > 0) {
+                    span.setAttribute("gen_ai.provider.retries_exhausted", true);
+                }
+                logger.warn(`[providerRetry] ${label} failed (non-retryable or retries exhausted)`, {
+                    attempt: attempt + 1,
+                    retryable,
+                    statusCode,
+                    error: errorMessage,
+                });
+                throw error;
+            }
+            // Calculate exponential backoff delay
+            const delay = BASE_RETRY_DELAY_MS * Math.pow(2, attempt);
+            // Record retry event on the OTel span
+            span.addEvent("gen_ai.provider.retry", {
+                "retry.attempt": attempt + 1,
+                "retry.delay_ms": delay,
+                ...(statusCode !== undefined && { "retry.status_code": statusCode }),
+                "retry.error": errorMessage.slice(0, 256),
+            });
+            logger.warn(`[providerRetry] ${label} retrying after ${statusCode || "unknown"} error`, {
+                attempt: attempt + 1,
+                maxRetries: MAX_PROVIDER_RETRIES,
+                delayMs: delay,
+                statusCode,
+                error: errorMessage,
+            });
+            await new Promise((r) => setTimeout(r, delay));
+        }
+    }
+    // This should never be reached due to the throw inside the loop,
+    // but TypeScript requires it for exhaustiveness.
+    throw new Error(`[providerRetry] ${label} exhausted all retries`);
+}
+//# sourceMappingURL=providerRetry.js.map

package/dist/lib/utils/retryability.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared HTTP retryability constants.
+ *
+ * Centralises the status-code lists that were duplicated across
+ * httpRetryHandler, neurolink.ts, fileDetector.ts, and errorHelpers.
+ */
+/** Server-side and rate-limiting codes worth retrying. */
+export declare const RETRYABLE_HTTP_STATUS_CODES: readonly number[];
+/** Client-error codes where retrying is pointless. */
+export declare const NON_RETRYABLE_HTTP_STATUS_CODES: readonly number[];
+/** Check whether an HTTP status code is retryable. */
+export declare function isRetryableStatusCode(code: number): boolean;
+/** Check whether an HTTP status code is non-retryable. */
+export declare function isNonRetryableStatusCode(code: number): boolean;

package/dist/lib/utils/retryability.js

@@ -0,0 +1,23 @@
+/**
+ * Shared HTTP retryability constants.
+ *
+ * Centralises the status-code lists that were duplicated across
+ * httpRetryHandler, neurolink.ts, fileDetector.ts, and errorHelpers.
+ */
+/** Server-side and rate-limiting codes worth retrying. */
+export const RETRYABLE_HTTP_STATUS_CODES = [
+    408, 429, 500, 502, 503, 504,
+];
+/** Client-error codes where retrying is pointless. */
+export const NON_RETRYABLE_HTTP_STATUS_CODES = [
+    400, 401, 403, 404, 405, 409, 422,
+];
+/** Check whether an HTTP status code is retryable. */
+export function isRetryableStatusCode(code) {
+    return RETRYABLE_HTTP_STATUS_CODES.includes(code);
+}
+/** Check whether an HTTP status code is non-retryable. */
+export function isNonRetryableStatusCode(code) {
+    return NON_RETRYABLE_HTTP_STATUS_CODES.includes(code);
+}
+//# sourceMappingURL=retryability.js.map

package/dist/lib/utils/sanitizers/svg.js

@@ -339,8 +339,7 @@ function removeDangerousAttributes(content, removedItems) {
         // Parse attributes
         const attrRegex = /([a-zA-Z][a-zA-Z0-9:_-]*)\s*=\s*(?:"([^"]*)"|'([^']*)')/g;
         const safeAttrs = [];
-        let attrMatch = attrRegex.exec(attrs);
-        while (attrMatch !== null) {
+        for (let attrMatch = attrRegex.exec(attrs); attrMatch !== null; attrMatch = attrRegex.exec(attrs)) {
             const attrName = attrMatch[1];
             const attrValue = attrMatch[2] ?? attrMatch[3] ?? "";
             const lowerAttrName = attrName.toLowerCase();
@@ -390,13 +389,13 @@ function removeDangerousAttributes(content, removedItems) {
             }
             // Attribute is safe, keep it
             safeAttrs.push(`${attrName}="${escapeAttributeValue(attrValue)}"`);
-            // Get next match
-            attrMatch = attrRegex.exec(attrs);
         }
         // Also keep standalone attributes (like xmlns without value in some cases)
         const standaloneAttrRegex = /\s([a-zA-Z][a-zA-Z0-9:_-]*)(?=\s|>|$|\/)/g;
         let standaloneMatch = standaloneAttrRegex.exec(attrs);
-        while (standaloneMatch !== null) {
+        let iterations = 0;
+        const MAX_ITERATIONS = 1000;
+        while (standaloneMatch !== null && iterations++ < MAX_ITERATIONS) {
             const attrName = standaloneMatch[1];
             // Only keep if it looks like a valid attribute and is safe
             if (SAFE_SVG_ATTRIBUTES.has(attrName) ||

package/dist/lib/utils/tokenEstimation.d.ts

@@ -16,7 +16,17 @@ import type { ChatMessage } from "../types/conversation.js";
 export declare const CHARS_PER_TOKEN = 4;
 /** Characters per token for code */
 export declare const CODE_CHARS_PER_TOKEN = 3;
-/** Safety margin to avoid underestimation */
+/**
+ * Safety margin: additive fraction of baseTokens added to the provider-adjusted estimate.
+ * Using additive margin prevents compounding with provider multipliers.
+ *
+ * Old behavior: baseTokens * providerMultiplier * 1.15  (compounding)
+ *   e.g. Anthropic: baseTokens * 1.23 * 1.15 = baseTokens * 1.4145
+ * New behavior: baseTokens * providerMultiplier + baseTokens * 0.05  (additive)
+ *   e.g. Anthropic: baseTokens * 1.23 + baseTokens * 0.05 = baseTokens * 1.28
+ */
+export declare const TOKEN_SAFETY_MARGIN_ADDITIVE = 0.05;
+/** @deprecated Use TOKEN_SAFETY_MARGIN_ADDITIVE instead. Kept for backward compatibility. */
 export declare const TOKEN_SAFETY_MARGIN = 1.15;
 /** Message framing overhead in tokens (role + delimiters) */
 export declare const TOKENS_PER_MESSAGE = 4;

package/dist/lib/utils/tokenEstimation.js

@@ -15,7 +15,17 @@
 export const CHARS_PER_TOKEN = 4;
 /** Characters per token for code */
 export const CODE_CHARS_PER_TOKEN = 3;
-/** Safety margin to avoid underestimation */
+/**
+ * Safety margin: additive fraction of baseTokens added to the provider-adjusted estimate.
+ * Using additive margin prevents compounding with provider multipliers.
+ *
+ * Old behavior: baseTokens * providerMultiplier * 1.15  (compounding)
+ *   e.g. Anthropic: baseTokens * 1.23 * 1.15 = baseTokens * 1.4145
+ * New behavior: baseTokens * providerMultiplier + baseTokens * 0.05  (additive)
+ *   e.g. Anthropic: baseTokens * 1.23 + baseTokens * 0.05 = baseTokens * 1.28
+ */
+export const TOKEN_SAFETY_MARGIN_ADDITIVE = 0.05;
+/** @deprecated Use TOKEN_SAFETY_MARGIN_ADDITIVE instead. Kept for backward compatibility. */
 export const TOKEN_SAFETY_MARGIN = 1.15;
 /** Message framing overhead in tokens (role + delimiters) */
 export const TOKENS_PER_MESSAGE = 4;
@@ -64,7 +74,11 @@ export function estimateTokens(text, provider, isCode) {
     const charsPerToken = isCode ? CODE_CHARS_PER_TOKEN : CHARS_PER_TOKEN;
     const baseTokens = Math.ceil(text.length / charsPerToken);
     const multiplier = getProviderMultiplier(provider);
-    return Math.ceil(baseTokens * multiplier * TOKEN_SAFETY_MARGIN);
+    // Apply provider multiplier and additive safety margin separately
+    // This prevents compounding (e.g. Anthropic: 1.23 * 1.15 = 1.41x was too aggressive)
+    const providerAdjusted = baseTokens * multiplier;
+    const safetyBuffer = baseTokens * TOKEN_SAFETY_MARGIN_ADDITIVE;
+    return Math.ceil(providerAdjusted + safetyBuffer);
 }
 /**
  * Estimate token count for a single ChatMessage.
@@ -114,8 +128,9 @@ export function truncateToTokenBudget(text, maxTokens, provider) {
         return { text, truncated: false };
     }
     const multiplier = getProviderMultiplier(provider);
-    const safetyFactor = multiplier * TOKEN_SAFETY_MARGIN;
-    const maxChars = Math.floor((maxTokens / safetyFactor) * CHARS_PER_TOKEN);
+    // Use additive safety margin: effective multiplier = multiplier + additive margin
+    const effectiveMultiplier = multiplier + TOKEN_SAFETY_MARGIN_ADDITIVE;
+    const maxChars = Math.floor((maxTokens / effectiveMultiplier) * CHARS_PER_TOKEN);
     if (maxChars <= 0) {
         return { text: "", truncated: true };
     }

package/dist/lib/utils/videoAnalysisProcessor.js

@@ -21,10 +21,14 @@ export function hasVideoFrames(messages) {
             return false;
         }
         if (Array.isArray(msg.content)) {
-            return msg.content.some((part) => typeof part === "object" &&
+            // Count image parts — only route to video analysis pipeline when there are
+            // multiple frames (3+), indicating actual video frame extraction.
+            // Single images or pairs should use the model's native vision capability.
+            const imageCount = msg.content.filter((part) => typeof part === "object" &&
                 part !== null &&
                 "type" in part &&
-                part.type === "image");
+                part.type === "image").length;
+            return imageCount >= 3;
         }
         return false;
     });
@@ -53,7 +57,7 @@ export async function executeVideoAnalysis(messages, options) {
             ? undefined
             : process.env.GOOGLE_VERTEX_PROJECT || process.env.GOOGLE_CLOUD_PROJECT,
         location: options.region || process.env.GOOGLE_VERTEX_LOCATION,
-        model: options.model || "gemini-2.0-flash",
+        model: options.model || "gemini-2.5-flash",
     });
     logger.debug("[VideoAnalysisProcessor] Video analysis completed", {
         hasResult: !!videoAnalysisText,

package/dist/mcp/externalServerManager.js

@@ -14,6 +14,9 @@ import { toolRegistry } from "./toolRegistry.js";
 import { HITLUserRejectedError, HITLTimeoutError } from "../hitl/hitlErrors.js";
 import { detectCategory } from "../utils/mcpDefaults.js";
 import { isObject, isNonNullObject } from "../utils/typeUtils.js";
+import { TelemetryService } from "../telemetry/telemetryService.js";
+import { tracers } from "../telemetry/tracers.js";
+import { SpanStatusCode } from "@opentelemetry/api";
 /**
  * Recursively substitute environment variables in strings
  * Replaces ${VAR_NAME} with the value from process.env.VAR_NAME
@@ -745,6 +748,16 @@ export class ExternalServerManager extends EventEmitter {
             throw new Error(`Server '${serverId}' not found`);
         }
         const config = instance.config;
+        const span = tracers.mcp.startSpan("neurolink.mcp.server.start", {
+            attributes: {
+                "mcp.server_id": serverId,
+                "mcp.transport": config.transport,
+                "mcp.command_name": config.command
+                    ? config.command.split(/[\\/]/).pop() || ""
+                    : "",
+                "mcp.command_present": Boolean(config.command),
+            },
+        });
         try {
             this.updateServerStatus(serverId, "connecting");
             mcpLogger.debug(`[ExternalServerManager] Starting server: ${serverId}`, {
@@ -803,6 +816,8 @@ export class ExternalServerManager extends EventEmitter {
                 toolCount: instance.toolsMap.size,
                 timestamp: new Date(),
             });
+            span.setAttribute("mcp.tool_count", instance.toolsMap.size);
+            span.setStatus({ code: SpanStatusCode.OK });
             mcpLogger.info(`[ExternalServerManager] Server started successfully: ${serverId}`);
         }
         catch (error) {
@@ -810,8 +825,16 @@ export class ExternalServerManager extends EventEmitter {
             this.updateServerStatus(serverId, "failed");
             instance.lastError =
                 error instanceof Error ? error.message : String(error);
+            span.recordException(error instanceof Error ? error : new Error(String(error)));
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error),
+            });
             throw error;
         }
+        finally {
+            span.end();
+        }
     }
     /**
      * Stop an external MCP server
@@ -821,6 +844,11 @@ export class ExternalServerManager extends EventEmitter {
         if (!instance) {
             return;
         }
+        const span = tracers.mcp.startSpan("neurolink.mcp.server.stop", {
+            attributes: {
+                "mcp.server_id": serverId,
+            },
+        });
         try {
             this.updateServerStatus(serverId, "stopping");
             // Clear timers
@@ -851,11 +879,20 @@ export class ExternalServerManager extends EventEmitter {
                 instance.process = null;
             }
             this.updateServerStatus(serverId, "stopped");
+            span.setStatus({ code: SpanStatusCode.OK });
             mcpLogger.info(`[ExternalServerManager] Server stopped: ${serverId}`);
         }
         catch (error) {
             mcpLogger.error(`[ExternalServerManager] Error stopping server ${serverId}:`, error);
             this.updateServerStatus(serverId, "failed");
+            span.recordException(error instanceof Error ? error : new Error(String(error)));
+            span.setStatus({
+                code: SpanStatusCode.ERROR,
+                message: error instanceof Error ? error.message : String(error),
+            });
+        }
+        finally {
+            span.end();
         }
     }
     /**
@@ -959,16 +996,32 @@ export class ExternalServerManager extends EventEmitter {
             return;
         } // already scheduled
         instance.restartTimer = setTimeout(async () => {
+            const restartSpan = tracers.mcp.startSpan("neurolink.mcp.server.restart", {
+                attributes: {
+                    "mcp.server_id": serverId,
+                    "mcp.restart_attempt": instance.reconnectAttempts,
+                    "mcp.restart_delay_ms": delay,
+                },
+            });
             try {
                 await this.stopServer(serverId);
                 await this.startServer(serverId);
                 // Reset restart attempts on successful restart
                 instance.reconnectAttempts = 0;
+                restartSpan.setStatus({ code: SpanStatusCode.OK });
             }
             catch (error) {
                 mcpLogger.error(`[ExternalServerManager] Restart failed for ${serverId}:`, error);
+                restartSpan.recordException(error instanceof Error ? error : new Error(String(error)));
+                restartSpan.setStatus({
+                    code: SpanStatusCode.ERROR,
+                    message: error instanceof Error ? error.message : String(error),
+                });
                 this.scheduleRestart(serverId); // Try again
             }
+            finally {
+                restartSpan.end();
+            }
         }, delay);
     }
     /**
@@ -1376,6 +1429,12 @@ export class ExternalServerManager extends EventEmitter {
                 mcpLogger.debug(`[ExternalServerManager] Tool executed successfully: ${toolName} on ${serverId}`, {
                     duration,
                 });
+                try {
+                    TelemetryService.getInstance()?.recordMCPToolCall(toolName, duration, true);
+                }
+                catch {
+                    /* telemetry should not break execution */
+                }
                 return result.data;
             }
             else {
@@ -1384,6 +1443,13 @@ export class ExternalServerManager extends EventEmitter {
         }
         catch (error) {
             instance.metrics.totalErrors++;
+            try {
+                const errorDuration = Date.now() - startTime;
+                TelemetryService.getInstance()?.recordMCPToolCall(toolName, errorDuration, false);
+            }
+            catch {
+                /* telemetry should not break execution */
+            }
             mcpLogger.error(`[ExternalServerManager] Tool execution failed: ${toolName} on ${serverId}`, error);
             throw error;
         }

package/dist/mcp/mcpCircuitBreaker.js

@@ -4,6 +4,7 @@
  * Provides fault tolerance and prevents cascading failures
  */
 import { EventEmitter } from "events";
+import { trace } from "@opentelemetry/api";
 import { mcpLogger } from "../utils/logger.js";
 /**
  * MCPCircuitBreaker
@@ -53,6 +54,17 @@ export class MCPCircuitBreaker extends EventEmitter {
                 this.halfOpenCalls >= this.config.halfOpenMaxCalls) {
                 throw new Error(`Circuit breaker '${this.name}' is half-open but call limit reached`);
             }
+            // NLK-GAP-009: Record half-open test event when executing in half-open state
+            if (this.state === "half-open") {
+                const activeSpan = trace.getActiveSpan();
+                if (activeSpan) {
+                    activeSpan.addEvent("circuit.half_open_test", {
+                        "circuit.name": this.name,
+                        "circuit.half_open_call": this.halfOpenCalls + 1,
+                        "circuit.half_open_max_calls": this.config.halfOpenMaxCalls,
+                    });
+                }
+            }
             // Execute operation with timeout
             const result = await Promise.race([
                 operation(),
@@ -145,6 +157,18 @@ export class MCPCircuitBreaker extends EventEmitter {
         const oldState = this.state;
         this.state = newState;
         this.lastStateChange = new Date();
+        // NLK-GAP-009: Record state transition on active OTel span
+        const activeSpan = trace.getActiveSpan();
+        if (activeSpan) {
+            activeSpan.addEvent("circuit.state_change", {
+                "circuit.name": this.name,
+                "circuit.from_state": oldState,
+                "circuit.to_state": newState,
+                "circuit.reason": reason.slice(0, 128),
+                "circuit.failure_count": this.callHistory.filter((c) => !c.success)
+                    .length,
+            });
+        }
         // Reset counters based on state
         if (newState === "half-open") {
             this.halfOpenCalls = 0;

package/dist/mcp/mcpClientFactory.js

@@ -15,6 +15,8 @@ import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
 import { withHTTPRetry, DEFAULT_HTTP_RETRY_CONFIG, } from "./httpRetryHandler.js";
 import { globalRateLimiterManager } from "./httpRateLimiter.js";
 import { NeuroLinkOAuthProvider, InMemoryTokenStorage } from "./auth/index.js";
+import { tracers } from "../telemetry/tracers.js";
+import { SpanStatusCode } from "@opentelemetry/api";
 /**
  * MCPClientFactory
  * Factory class for creating MCP clients with different transports
@@ -36,6 +38,13 @@ export class MCPClientFactory {
      */
     static async createClient(config, timeout = 10000) {
         const startTime = Date.now();
+        const span = tracers.mcp.startSpan("neurolink.mcp.client.create", {
+            attributes: {
+                "mcp.server_id": config.id,
+                "mcp.transport": config.transport,
+                "mcp.timeout_ms": timeout,
+            },
+        });
         try {
             mcpLogger.info(`[MCPClientFactory] Creating client for ${config.id}`, {
                 transport: config.transport,
@@ -94,6 +103,7 @@ export class MCPClientFactory {
                 duration: Date.now() - startTime,
                 capabilities: result.capabilities,
             });
+            span.setStatus({ code: SpanStatusCode.OK });
             return {
                 ...result,
                 success: true,
@@ -103,12 +113,18 @@ export class MCPClientFactory {
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             mcpLogger.error(`[MCPClientFactory] Failed to create client for ${config.id}:`, error);
+            // NLK-GAP-004 fix: Record both exception AND error status on span
+            span.recordException(error instanceof Error ? error : new Error(errorMessage));
+            span.setStatus({ code: SpanStatusCode.ERROR, message: errorMessage });
             return {
                 success: false,
                 error: errorMessage,
                 duration: Date.now() - startTime,
             };
         }
+        finally {
+            span.end();
+        }
     }
     /**
      * Internal client creation logic

package/dist/mcp/toolDiscoveryService.js

@@ -8,6 +8,10 @@ import { mcpLogger } from "../utils/logger.js";
 import { globalCircuitBreakerManager } from "./mcpCircuitBreaker.js";
 import { isObject, isNullish } from "../utils/typeUtils.js";
 import { validateToolName, validateToolDescription, } from "../utils/parameterValidation.js";
+import { withTimeout } from "../utils/errorHandling.js";
+import { SpanKind, SpanStatusCode } from "@opentelemetry/api";
+import { tracers } from "../telemetry/tracers.js";
+const mcpTracer = tracers.mcp;
 /**
  * ToolDiscoveryService
  * Handles automatic tool discovery and registration from external MCP servers
@@ -336,13 +340,35 @@ export class ToolDiscoveryService extends EventEmitter {
             });
             // Execute tool with circuit breaker protection
             const result = await circuitBreaker.execute(async () => {
-                const timeout = options.timeout || 30000;
-                const executePromise = client.callTool({
-                    name: toolName,
-                    arguments: parameters,
+                return mcpTracer.startActiveSpan("neurolink.mcp.callTool", {
+                    kind: SpanKind.CLIENT,
+                    attributes: {
+                        "mcp.server_id": serverId,
+                        "mcp.tool_name": toolName,
+                        "mcp.timeout_ms": options.timeout || 30000,
+                    },
+                }, async (callSpan) => {
+                    try {
+                        const timeout = options.timeout || 30000;
+                        const callResult = await withTimeout(client.callTool({
+                            name: toolName,
+                            arguments: parameters,
+                        }), timeout, new Error(`Tool execution timeout: ${toolName}`));
+                        callSpan.setStatus({ code: SpanStatusCode.OK });
+                        return callResult;
+                    }
+                    catch (err) {
+                        callSpan.setStatus({
+                            code: SpanStatusCode.ERROR,
+                            message: err.message,
+                        });
+                        callSpan.recordException(err);
+                        throw err;
+                    }
+                    finally {
+                        callSpan.end();
+                    }
                 });
-                const timeoutPromise = this.createTimeoutPromise(timeout, `Tool execution timeout: ${toolName}`);
-                return await Promise.race([executePromise, timeoutPromise]);
             });
             const duration = Date.now() - startTime;
             // Update tool statistics