@posthog/mcp 0.10.4 → 0.10.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@posthog/mcp",
-  "version": "0.10.4",
+  "version": "0.10.6",
   "bugs": {
     "url": "https://github.com/PostHog/posthog-js/issues"
   },
@@ -39,8 +39,8 @@
     "@types/node": "^20.0.0",
     "jest": "29.7.0",
     "zod": "^3.25.0",
-    "@posthog-tooling/tsconfig-base": "1.1.1",
-    "posthog-node": "^5.47.8"
+    "posthog-node": "^5.47.8",
+    "@posthog-tooling/tsconfig-base": "1.1.1"
   },
   "peerDependencies": {
     "@modelcontextprotocol/sdk": ">=1.26.0",

package/src/extensions/capture.ts

@@ -6,7 +6,7 @@
 import type { MCPServerLike, McpEvent } from '../types'
 import { MCPAnalyticsEventType } from './event-types'
 import { getServerTrackingData } from './internal'
-import { log } from './logger'
+import type { LoggerFn } from './logger'
 import { getSessionInfo } from './session'
 
 /**
@@ -19,10 +19,10 @@ import { getSessionInfo } from './session'
  * Auto-capture callers (tool calls, listings, identify) intentionally ignore the
  * return value, keeping the tool path isolated from analytics latency/errors.
  */
-export function captureEvent(server: MCPServerLike, eventInput: McpEvent): Promise<void> | undefined {
+export function captureEvent(server: MCPServerLike, eventInput: McpEvent, logger: LoggerFn): Promise<void> | undefined {
   const data = getServerTrackingData(server)
   if (!data) {
-    log('Warning: Server tracking data not found. Event will not be published.')
+    logger('Warning: Server tracking data not found. Event will not be published.')
     return
   }
 

package/src/extensions/compatibility.ts

@@ -4,7 +4,7 @@
 // Licensed under the MIT License: https://github.com/agentcathq/agentcat-typescript-sdk/blob/main/LICENSE
 
 import type { HighLevelMCPServerLike, MCPServerLike } from '../types'
-import { log } from './logger'
+import type { LoggerFn } from './logger'
 
 type ServerRecord = Record<string, unknown>
 
@@ -22,8 +22,8 @@ type ServerRecord = Record<string, unknown>
  */
 
 // Function to log compatibility information
-export function logCompatibilityWarning(): void {
-  log(
+export function logCompatibilityWarning(logger: LoggerFn): void {
+  logger(
     'PostHog MCP analytics SDK Compatibility: This version only supports Model Context Protocol TypeScript SDK v1.11 and above. Please upgrade if using an older version.'
   )
 }
@@ -41,9 +41,9 @@ export function isLowLevelServer(server: unknown): server is ServerRecord {
 }
 
 // Type guard function that validates server compatibility and returns typed server
-export function isCompatibleServerType(server: unknown): MCPServerLike | HighLevelMCPServerLike {
+export function isCompatibleServerType(server: unknown, logger: LoggerFn): MCPServerLike | HighLevelMCPServerLike {
   if (!server || typeof server !== 'object') {
-    logCompatibilityWarning()
+    logCompatibilityWarning(logger)
     throw new Error(
       "PostHog MCP analytics SDK compatibility error: Server must be an object. Ensure you're using MCP SDK v1.11 or higher."
     )
@@ -52,13 +52,13 @@ export function isCompatibleServerType(server: unknown): MCPServerLike | HighLev
   if (isHighLevelServer(server)) {
     // Validate high-level server requirements
     if (!server._registeredTools || typeof server._registeredTools !== 'object') {
-      logCompatibilityWarning()
+      logCompatibilityWarning(logger)
       throw new Error(
         'PostHog MCP analytics SDK compatibility error: High-level server must have _registeredTools object. This requires MCP SDK v1.11 or higher.'
       )
     }
     if (typeof server.tool !== 'function') {
-      logCompatibilityWarning()
+      logCompatibilityWarning(logger)
       throw new Error(
         'PostHog MCP analytics SDK compatibility error: High-level server must have tool() method. This requires MCP SDK v1.11 or higher.'
       )
@@ -66,19 +66,19 @@ export function isCompatibleServerType(server: unknown): MCPServerLike | HighLev
 
     // Validate the underlying low-level server
     const targetServer = server.server
-    validateLowLevelServer(targetServer)
+    validateLowLevelServer(targetServer, logger)
 
     return server as unknown as HighLevelMCPServerLike
   }
   // Direct low-level server validation
-  validateLowLevelServer(server)
+  validateLowLevelServer(server, logger)
   return server as MCPServerLike
 }
 
 // Helper function to validate low-level server requirements
-function validateLowLevelServer(server: unknown): void {
+function validateLowLevelServer(server: unknown, logger: LoggerFn): void {
   if (!server || typeof server !== 'object') {
-    logCompatibilityWarning()
+    logCompatibilityWarning(logger)
     throw new Error(
       "PostHog MCP analytics SDK compatibility error: Server must be an object. Ensure you're using MCP SDK v1.11 or higher."
     )
@@ -87,14 +87,14 @@ function validateLowLevelServer(server: unknown): void {
   const serverRecord = server as ServerRecord
 
   if (typeof serverRecord.setRequestHandler !== 'function') {
-    logCompatibilityWarning()
+    logCompatibilityWarning(logger)
     throw new Error(
       'PostHog MCP analytics SDK compatibility error: Server must have a setRequestHandler method. This requires MCP SDK v1.11 or higher.'
     )
   }
 
   if (!(serverRecord._requestHandlers && serverRecord._requestHandlers instanceof Map)) {
-    logCompatibilityWarning()
+    logCompatibilityWarning(logger)
     throw new Error(
       'PostHog MCP analytics SDK compatibility error: Server._requestHandlers is not accessible. This requires MCP SDK v1.11 or higher.'
     )
@@ -102,14 +102,14 @@ function validateLowLevelServer(server: unknown): void {
 
   // Validate that _requestHandlers contains functions with compatible signatures
   if (typeof serverRecord._requestHandlers.get !== 'function') {
-    logCompatibilityWarning()
+    logCompatibilityWarning(logger)
     throw new Error(
       'PostHog MCP analytics SDK compatibility error: Server._requestHandlers must be a Map with a get method. This requires MCP SDK v1.11 or higher.'
     )
   }
 
   if (typeof serverRecord.getClientVersion !== 'function') {
-    logCompatibilityWarning()
+    logCompatibilityWarning(logger)
     throw new Error(
       'PostHog MCP analytics SDK compatibility error: Server.getClientVersion must be a function. This requires MCP SDK v1.11 or higher.'
     )
@@ -120,7 +120,7 @@ function validateLowLevelServer(server: unknown): void {
     typeof serverRecord._serverInfo !== 'object' ||
     !('name' in serverRecord._serverInfo)
   ) {
-    logCompatibilityWarning()
+    logCompatibilityWarning(logger)
     throw new Error(
       'PostHog MCP analytics SDK compatibility error: Server._serverInfo is not accessible or missing name. This requires MCP SDK v1.11 or higher.'
     )

package/src/extensions/context-parameters.ts

@@ -10,7 +10,7 @@ import {
   type AnalyticsInjectableJsonSchema,
 } from './analytics-parameters'
 import { DEFAULT_CONTEXT_PARAMETER_DESCRIPTION } from './constants'
-import { log } from './logger'
+import { log, type LoggerFn } from './logger'
 
 export interface ContextInjectableTool {
   inputSchema?: AnalyticsInjectableJsonSchema
@@ -38,7 +38,8 @@ export function getContextDescription(context: MCPAnalyticsOptions['context']):
  */
 export function addContextParameterToTool<TTool extends ContextInjectableTool>(
   tool: TTool,
-  contextDescriptionOverride?: string
+  contextDescriptionOverride?: string,
+  logger: LoggerFn = log
 ): TTool {
   // Create a shallow copy of the tool to avoid modifying the original
   const modifiedTool = { ...tool }
@@ -47,9 +48,9 @@ export function addContextParameterToTool<TTool extends ContextInjectableTool>(
 
   if (!canInjectAnalyticsParameter(schema, 'context')) {
     if (hasAnalyticsParameter(schema, 'context')) {
-      log(`WARN: Tool "${toolName}" already has 'context' parameter. Skipping context injection.`)
+      logger(`WARN: Tool "${toolName}" already has 'context' parameter. Skipping context injection.`)
     } else {
-      log(`WARN: Tool "${toolName}" has complex schema (oneOf/allOf/anyOf/$ref). Skipping context injection.`)
+      logger(`WARN: Tool "${toolName}" has complex schema (oneOf/allOf/anyOf/$ref). Skipping context injection.`)
     }
     return modifiedTool
   }
@@ -104,13 +105,8 @@ export function addContextParameterToTool<TTool extends ContextInjectableTool>(
 
 export function addContextParameterToTools<TTool extends ContextInjectableTool>(
   tools: TTool[],
-  contextDescriptionOverride?: string
+  contextDescriptionOverride?: string,
+  logger: LoggerFn = log
 ): TTool[] {
-  return tools.map((tool) => {
-    // Skip get_more_tools - it has its own special context parameter
-    if (tool.name === 'get_more_tools') {
-      return tool
-    }
-    return addContextParameterToTool(tool, contextDescriptionOverride)
-  })
+  return tools.map((tool) => addContextParameterToTool(tool, contextDescriptionOverride, logger))
 }

package/src/extensions/conversation-id.ts

@@ -10,7 +10,7 @@ import {
   type AnalyticsInjectableJsonSchema,
 } from './analytics-parameters'
 import { DEFAULT_CONVERSATION_ID_DESCRIPTION } from './constants'
-import { log } from './logger'
+import { log, type LoggerFn } from './logger'
 import { GET_MORE_TOOLS_NAME } from './tools'
 
 export const CONVERSATION_ID_PARAM_NAME = 'conversation_id'
@@ -21,18 +21,23 @@ export interface ConversationIdInjectableTool {
   [key: string]: unknown
 }
 
-export function addConversationIdToTool<TTool extends ConversationIdInjectableTool>(tool: TTool): TTool {
+export function addConversationIdToTool<TTool extends ConversationIdInjectableTool>(
+  tool: TTool,
+  logger: LoggerFn = log
+): TTool {
   const modifiedTool = { ...tool }
   const toolName = tool.name || 'unknown'
   const schema = modifiedTool.inputSchema as AnalyticsInjectableJsonSchema | undefined
 
   if (!canInjectAnalyticsParameter(schema, CONVERSATION_ID_PARAM_NAME)) {
     if (hasAnalyticsParameter(schema, CONVERSATION_ID_PARAM_NAME)) {
-      log(
+      logger(
         `WARN: Tool "${toolName}" already has '${CONVERSATION_ID_PARAM_NAME}' parameter. Skipping conversation_id injection.`
       )
     } else {
-      log(`WARN: Tool "${toolName}" has complex schema (oneOf/allOf/anyOf/$ref). Skipping conversation_id injection.`)
+      logger(
+        `WARN: Tool "${toolName}" has complex schema (oneOf/allOf/anyOf/$ref). Skipping conversation_id injection.`
+      )
     }
     return modifiedTool
   }
@@ -67,13 +72,15 @@ export function addConversationIdToTool<TTool extends ConversationIdInjectableTo
 
 export function addConversationIdToTools<TTool extends ConversationIdInjectableTool>(
   tools: TTool[],
-  missingCapabilityToolName: string = GET_MORE_TOOLS_NAME
+  missingCapabilityToolName: string = GET_MORE_TOOLS_NAME,
+  skipMissingCapabilityTool = true,
+  logger: LoggerFn = log
 ): TTool[] {
   return tools.map((tool) => {
-    if (tool.name === missingCapabilityToolName) {
+    if (skipMissingCapabilityTool && tool.name === missingCapabilityToolName) {
       return tool
     }
-    return addConversationIdToTool(tool)
+    return addConversationIdToTool(tool, logger)
   })
 }
 

package/src/extensions/instrument-highlevel.ts

@@ -19,7 +19,7 @@ import {
 import { isContextEnabled } from './context-parameters'
 import { MCPAnalyticsEventType } from './event-types'
 import { getServerTrackingData } from './internal'
-import { log } from './logger'
+import type { LoggerFn } from './logger'
 import { createWrappedTool, getToolFunction, hasToolFunction } from './mcp-sdk-compat'
 import { handleReportMissing, resolveMissingCapabilityToolName } from './tools'
 import {
@@ -27,7 +27,9 @@ import {
   handleListToolsRequest,
   patchRequestHandlers,
   captureToolCall,
+  isToolAdvertised,
   readToolMetaCategory,
+  type HandlerPatch,
 } from './instrumentation'
 import { getContextArgument } from './tracing-helpers'
 
@@ -51,18 +53,22 @@ function isCallbackUpdate(value: unknown): value is { callback: ToolCallback } {
 
 function addTracingToToolRegistry(
   tools: Record<string, RegisteredTool>,
-  server: HighLevelMCPServerLike
+  server: HighLevelMCPServerLike,
+  logger: LoggerFn
 ): Record<string, RegisteredTool> {
   return Object.fromEntries(
-    Object.entries(tools).map(([name, tool]) => [name, addTracingToToolCallbackInternal(tool, name, server)])
+    Object.entries(tools).map(([name, tool]) => [
+      name,
+      addTracingToToolCallbackInternal(tool, name, server, () => tool.inputSchema, logger),
+    ])
   )
 }
 
-function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
+function setupListenerToRegisteredTools(server: HighLevelMCPServerLike, logger: LoggerFn): void {
   try {
     const data = getServerTrackingData(server.server as MCPServerLike)
     if (!data) {
-      log('Warning: Cannot setup listener - no tracking data found')
+      logger('Warning: Cannot setup listener - no tracking data found')
       return
     }
 
@@ -74,19 +80,19 @@ function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
               data.toolDescriptions.set(property, value.description)
             }
             if ((value as ProcessedRegisteredTool)[MCP_ANALYTICS_PROCESSED]) {
-              log(`Tool ${String(property)} already processed, skipping proxy wrapping`)
+              logger(`Tool ${String(property)} already processed, skipping proxy wrapping`)
               return Reflect.set(target, property, value)
             }
 
             if (wrappedCallbacks.has(getToolFunction(value))) {
-              log(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`)
+              logger(`Tool ${String(property)} callback already wrapped, skipping proxy wrapping`)
               return Reflect.set(target, property, value)
             }
 
             // The MCP SDK's registry copy is currently stale after update(), but keep this lookup lazy so
             // ownership follows the current schema once the registry reflects live tool state.
             const getCurrentInputSchema = () => value.inputSchema
-            const nextValue = addTracingToToolCallbackInternal(value, property, server, getCurrentInputSchema)
+            const nextValue = addTracingToToolCallbackInternal(value, property, server, getCurrentInputSchema, logger)
 
             if (typeof nextValue.update === 'function') {
               const originalUpdate = nextValue.update
@@ -98,7 +104,8 @@ function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
                       { callback: updateObj.callback },
                       property,
                       server,
-                      getCurrentInputSchema
+                      getCurrentInputSchema,
+                      logger
                     )
                     updateObj.callback = getToolFunction(wrappedTool)
                   }
@@ -111,7 +118,7 @@ function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
 
           return Reflect.set(target, property, value)
         } catch (error) {
-          log(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`)
+          logger(`Warning: Error in proxy set handler for tool ${String(property)} - ${error}`)
           return Reflect.set(target, property, value)
         }
       },
@@ -132,9 +139,9 @@ function setupListenerToRegisteredTools(server: HighLevelMCPServerLike): void {
     const originalTools = server._registeredTools || {}
     server._registeredTools = new Proxy(originalTools, handler)
 
-    log('Successfully set up listener for new tool registrations')
+    logger('Successfully set up listener for new tool registrations')
   } catch (error) {
-    log(`Warning: Failed to setup listener for registered tools - ${error}`)
+    logger(`Warning: Failed to setup listener for registered tools - ${error}`)
   }
 }
 
@@ -151,19 +158,18 @@ function addTracingToToolCallbackInternal(
   tool: RegisteredTool,
   toolName: string,
   server: HighLevelMCPServerLike,
-  getCurrentInputSchema: () => unknown = () => tool.inputSchema
+  getCurrentInputSchema: () => unknown,
+  logger: LoggerFn
 ): RegisteredTool {
   const originalCallback = getToolFunction(tool)
   const options = getServerTrackingData(server.server as MCPServerLike)?.options
-  const missingToolName = resolveMissingCapabilityToolName(options)
-
   if (wrappedCallbacks.has(originalCallback)) {
-    log(`Tool ${toolName} callback already wrapped, skipping re-wrap`)
+    logger(`Tool ${toolName} callback already wrapped, skipping re-wrap`)
     return tool
   }
 
   if ((tool as ProcessedRegisteredTool)[MCP_ANALYTICS_PROCESSED]) {
-    log(`Tool ${toolName} already processed, skipping re-wrap`)
+    logger(`Tool ${toolName} already processed, skipping re-wrap`)
     return tool
   }
 
@@ -181,16 +187,9 @@ function addTracingToToolCallbackInternal(
 
     const inputSchema = getCurrentInputSchema()
     const cleanedArgs = stripOwnedAnalyticsArguments(args, {
-      context:
-        toolName !== missingToolName &&
-        isContextEnabled(options?.context) &&
-        analyticsOwnsParameter(inputSchema, 'context'),
-      conversationId:
-        toolName !== missingToolName &&
-        options?.enableConversationId === true &&
-        analyticsOwnsParameter(inputSchema, 'conversation_id'),
+      context: isContextEnabled(options?.context) && analyticsOwnsParameter(inputSchema, 'context'),
+      conversationId: options?.enableConversationId === true && analyticsOwnsParameter(inputSchema, 'conversation_id'),
     })
-
     try {
       if (cleanedArgs === undefined) {
         const handler = originalCallback as (extra: CompatibleRequestHandlerExtra) => Promise<CallToolResult>
@@ -224,17 +223,22 @@ async function handleToolCallRequest(
   server: MCPServerLike,
   originalCallToolHandler: MCPRequestHandler,
   request: MCPRequest,
-  extra: MCPRequestExtra
+  extra: MCPRequestExtra,
+  logger: LoggerFn
 ): Promise<unknown> {
   const data = getServerTrackingData(server)
   if (!data) {
-    log(
+    logger(
       'Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.'
     )
     return await originalCallToolHandler(request, extra)
   }
 
-  if (request.params?.name === resolveMissingCapabilityToolName(data.options)) {
+  const toolName = request.params?.name
+  const isMissingCapabilityCandidate =
+    data.options.reportMissing && toolName === resolveMissingCapabilityToolName(data.options)
+
+  if (isMissingCapabilityCandidate && (await isToolAdvertised(server, toolName, extra, data.logger)) === false) {
     const context = getContextArgument(request) || ''
     return await captureToolCall({
       server,
@@ -243,11 +247,10 @@ async function handleToolCallRequest(
       extra,
       eventType: MCPAnalyticsEventType.mcpMissingCapability,
       explicitContextIntent: context,
-      execute: async () => handleReportMissing({ context }),
+      execute: async () => handleReportMissing({ context }, data.logger),
     })
   }
 
-  const toolName = request.params?.name
   const registeredTool = toolName ? highLevelServer._registeredTools[toolName] : undefined
 
   // Strip SDK-owned arguments before the MCP SDK validates the registered Zod
@@ -270,34 +273,32 @@ async function handleToolCallRequest(
   })
 }
 
-export function instrumentHighLevelServer(server: HighLevelMCPServerLike): void {
+export function instrumentHighLevelServer(server: HighLevelMCPServerLike, logger: LoggerFn): void {
   try {
     const lowLevelServer = server.server
     const mcpAnalyticsData = getServerTrackingData(lowLevelServer)
 
     // Patch already existing handlers, and patch setRequestHandler to capture dynamically created handlers.
-    const handlers = {
-      initialize: handleInitializeRequest,
-      'tools/list': handleListToolsRequest,
-      'tools/call': (
-        trackedServer: MCPServerLike,
-        originalHandler: MCPRequestHandler,
-        request: MCPRequest,
-        extra: MCPRequestExtra
-      ) => handleToolCallRequest(server, trackedServer, originalHandler, request, extra),
+    const handlers: Record<string, HandlerPatch> = {
+      initialize: (trackedServer, originalHandler, request, extra) =>
+        handleInitializeRequest(trackedServer, originalHandler, request, extra, logger),
+      'tools/list': (trackedServer, originalHandler, request, extra) =>
+        handleListToolsRequest(trackedServer, originalHandler, request, extra, logger),
+      'tools/call': (trackedServer, originalHandler, request, extra) =>
+        handleToolCallRequest(server, trackedServer, originalHandler, request, extra, logger),
     }
     patchRequestHandlers(lowLevelServer, handlers)
 
-    server._registeredTools = addTracingToToolRegistry(server._registeredTools, server)
+    server._registeredTools = addTracingToToolRegistry(server._registeredTools, server, logger)
 
     if (mcpAnalyticsData) {
       seedToolDescriptionsFromRegistry(mcpAnalyticsData.toolDescriptions, server._registeredTools)
       seedToolCategoriesFromRegistry(mcpAnalyticsData.toolCategories, server._registeredTools)
     }
 
-    setupListenerToRegisteredTools(server)
+    setupListenerToRegisteredTools(server, logger)
   } catch (error) {
-    log(`Warning: Failed to setup tool call instrumentation - ${error}`)
+    logger(`Warning: Failed to setup tool call instrumentation - ${error}`)
   }
 }
 

package/src/extensions/instrument-lowlevel.ts

@@ -7,13 +7,15 @@ import { CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js'
 import type { CompatibleRequestHandlerExtra, MCPRequestLike, MCPServerLike } from '../types'
 import { MCPAnalyticsEventType } from './event-types'
 import { getServerTrackingData } from './internal'
-import { log } from './logger'
+import type { LoggerFn } from './logger'
 import { handleReportMissing, resolveMissingCapabilityToolName } from './tools'
 import {
   handleInitializeRequest,
   handleListToolsRequest,
   patchRequestHandlers,
   captureToolCall,
+  isToolAdvertised,
+  type HandlerPatch,
 } from './instrumentation'
 import { getContextArgument } from './tracing-helpers'
 
@@ -28,22 +30,30 @@ type MCPRequestExtra = Parameters<MCPRequestHandler>[1]
  * `tools/call`. The tool-call lifecycle is delegated to {@link captureToolCall},
  * shared with the high-level wrapper.
  */
-export function instrumentLowLevelServer(server: MCPServerLike): void {
+export function instrumentLowLevelServer(server: MCPServerLike, logger: LoggerFn): void {
   try {
     // Patch already existing handlers, and patch setRequestHandler to capture dynamically created handlers.
-    const handlers = {
-      initialize: handleInitializeRequest,
-      'tools/list': handleListToolsRequest,
+    const hadCallToolHandler = server._requestHandlers.has('tools/call')
+    const handlers: Record<string, HandlerPatch> = {
+      initialize: (server, originalHandler, request, extra) =>
+        handleInitializeRequest(server, originalHandler, request, extra, logger),
+      'tools/list': (server, originalHandler, request, extra) =>
+        handleListToolsRequest(server, originalHandler, request, extra, logger),
+      'tools/call': (server, originalHandler, request, extra) =>
+        handleToolCallRequest(server, originalHandler, request, extra, logger),
     }
     patchRequestHandlers(server, handlers)
 
-    const originalCallToolHandler = server._requestHandlers.get('tools/call')
-    server.setRequestHandler(
-      CallToolRequestSchema,
-      async (request, extra) => await handleToolCallRequest(server, originalCallToolHandler, request, extra)
-    )
+    if (!hadCallToolHandler) {
+      // Register a raw fallback through the patched setter so reportMissing works
+      // even before an application dispatcher is attached. A later registration
+      // replaces it and is wrapped by patchRequestHandlers.
+      server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        throw new Error(`Unknown tool: ${request.params?.name || 'unknown'}`)
+      })
+    }
   } catch (error) {
-    log(`Warning: Failed to setup tool call instrumentation - ${error}`)
+    logger(`Warning: Failed to setup tool call instrumentation - ${error}`)
     throw error
   }
 }
@@ -52,17 +62,22 @@ async function handleToolCallRequest(
   server: MCPServerLike,
   originalCallToolHandler: MCPRequestHandler | undefined,
   request: MCPRequest,
-  extra: MCPRequestExtra
+  extra: MCPRequestExtra,
+  logger: LoggerFn
 ): Promise<unknown> {
   const data = getServerTrackingData(server)
   if (!data) {
-    log(
+    logger(
       'Warning: PostHog MCP analytics is unable to find server tracking data. Please ensure you have called instrument(server, options) before using tool calls.'
     )
     return await originalCallToolHandler?.(request, extra)
   }
 
-  if (request.params?.name === resolveMissingCapabilityToolName(data.options)) {
+  const toolName = request.params?.name
+  const isMissingCapabilityCandidate =
+    data.options.reportMissing && toolName === resolveMissingCapabilityToolName(data.options)
+
+  if (isMissingCapabilityCandidate && (await isToolAdvertised(server, toolName, extra, data.logger)) === false) {
     const context = getContextArgument(request) || ''
     return await captureToolCall({
       server,
@@ -71,7 +86,7 @@ async function handleToolCallRequest(
       extra,
       eventType: MCPAnalyticsEventType.mcpMissingCapability,
       explicitContextIntent: context,
-      execute: async () => handleReportMissing({ context }),
+      execute: async () => handleReportMissing({ context }, data.logger),
     })
   }