@posthog/mcp 0.10.3 → 0.10.5

package/src/extensions/instrument-lowlevel.ts

@@ -7,13 +7,14 @@ 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,
+  type HandlerPatch,
 } from './instrumentation'
 import { getContextArgument } from './tracing-helpers'
 
@@ -28,22 +29,24 @@ 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 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),
     }
     patchRequestHandlers(server, handlers)
 
     const originalCallToolHandler = server._requestHandlers.get('tools/call')
     server.setRequestHandler(
       CallToolRequestSchema,
-      async (request, extra) => await handleToolCallRequest(server, originalCallToolHandler, request, extra)
+      async (request, extra) => await handleToolCallRequest(server, originalCallToolHandler, request, extra, logger)
     )
   } catch (error) {
-    log(`Warning: Failed to setup tool call instrumentation - ${error}`)
+    logger(`Warning: Failed to setup tool call instrumentation - ${error}`)
     throw error
   }
 }
@@ -52,11 +55,12 @@ 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)
@@ -71,7 +75,7 @@ async function handleToolCallRequest(
       extra,
       eventType: MCPAnalyticsEventType.mcpMissingCapability,
       explicitContextIntent: context,
-      execute: async () => handleReportMissing({ context }),
+      execute: async () => handleReportMissing({ context }, data.logger),
     })
   }
 

package/src/extensions/instrumentation.ts

@@ -5,6 +5,7 @@
 
 import type { ListToolsResult } from '@modelcontextprotocol/sdk/types.js'
 import type {
+  AnalyticsParameterOwnership,
   CompatibleRequestHandlerExtra,
   MCPAnalyticsData,
   MCPRequestLike,
@@ -12,12 +13,12 @@ import type {
   McpEvent,
   ServerClientInfoLike,
 } from '../types'
+import { getAnalyticsParameterOwnership, stripOwnedAnalyticsArguments } from './analytics-parameters'
 import { addContextParameterToTools, getContextDescription, isContextEnabled } from './context-parameters'
 import {
   addConversationIdToTools,
   type ConversationIdResolution,
   canInjectConversationIdPromptBack,
-  cloneRequestWithoutConversationId,
   injectConversationIdPromptBack,
   resolveConversationId,
 } from './conversation-id'
@@ -27,7 +28,7 @@ import { MCPAnalyticsEventType } from './event-types'
 import { captureException } from './exceptions'
 import { resolveToolCallIntent, setEventIntent, setExplicitContextIntent } from './intent'
 import { getServerTrackingData, handleIdentify, setServerTrackingData } from './internal'
-import { log } from './logger'
+import type { LoggerFn } from './logger'
 import { buildCapturedMcpParameters } from './mcp-payloads'
 import { getLiteralValue, getObjectShape } from './mcp-sdk-compat'
 import { getSessionId, newSessionId } from './session'
@@ -45,11 +46,7 @@ import { applyResolvedMetadata, isToolResultError } from './tracing-helpers'
 
 type MCPRequestHandler = (request: MCPRequestLike, extra?: CompatibleRequestHandlerExtra) => Promise<unknown>
 
-/**
- * Runs the underlying tool. Receives the request with the SDK-injected
- * `conversation_id` stripped; an adapter is free to ignore it (the high-level
- * path strips arguments inside the wrapped callback instead).
- */
+/** Runs the underlying tool with SDK-owned analytics arguments removed. */
 type ToolExecutor = (downstreamRequest: MCPRequestLike) => Promise<unknown>
 
 interface TraceToolCallParams {
@@ -58,6 +55,8 @@ interface TraceToolCallParams {
   request: MCPRequestLike
   extra?: CompatibleRequestHandlerExtra
   execute: ToolExecutor
+  /** Optional schema-derived ownership override for adapters with direct registry access. */
+  parameterOwnership?: AnalyticsParameterOwnership
   /**
    * Event type to capture. Defaults to a tool call; the `get_more_tools` virtual
    * tool passes `mcpMissingCapability` so it records a capability gap rather than
@@ -88,15 +87,26 @@ interface TraceToolCallParams {
  * throws, and the tool's own errors are always re-thrown to the caller.
  */
 export async function captureToolCall(params: TraceToolCallParams): Promise<unknown> {
-  const { server, data, request, extra, execute, eventType, explicitContextIntent, takeCapturedError } = params
-
+  const {
+    server,
+    data,
+    request,
+    extra,
+    execute,
+    parameterOwnership,
+    eventType,
+    explicitContextIntent,
+    takeCapturedError,
+  } = params
+
+  const ownership = getActiveAnalyticsParameterOwnership(data, request.params?.name, parameterOwnership)
   const conversation = resolveConversationId(
-    data.options.enableConversationId ?? false,
+    ownership.conversationId,
     request.params?.arguments,
     request.params?.name,
     resolveMissingCapabilityToolName(data.options)
   )
-  const downstreamRequest = conversation.conversationId ? cloneRequestWithoutConversationId(request) : request
+  const downstreamRequest = cloneRequestWithoutOwnedAnalyticsArguments(request, ownership)
 
   // Prepare the event in isolation: if identity/metadata/intent resolution
   // throws, we drop instrumentation for this call but still run the tool.
@@ -109,6 +119,7 @@ export async function captureToolCall(params: TraceToolCallParams): Promise<unkn
     extra,
     startTime,
     conversation,
+    ownership,
     eventType ?? MCPAnalyticsEventType.mcpToolsCall
   )
   if (event && explicitContextIntent) {
@@ -119,15 +130,47 @@ export async function captureToolCall(params: TraceToolCallParams): Promise<unkn
   try {
     result = await execute(downstreamRequest)
   } catch (error) {
-    publishFailedToolEvent(server, event, error, startTime, conversation)
+    publishFailedToolEvent(server, event, error, startTime, conversation, data.logger)
     throw error
   }
 
   const finalResult = applyConversationPromptBack(event, result, conversation)
-  publishSuccessfulToolEvent(server, event, finalResult, startTime, takeCapturedError)
+  publishSuccessfulToolEvent(server, event, finalResult, startTime, data.logger, takeCapturedError)
   return finalResult
 }
 
+function getActiveAnalyticsParameterOwnership(
+  data: MCPAnalyticsData,
+  toolName: string | undefined,
+  override?: AnalyticsParameterOwnership
+): AnalyticsParameterOwnership {
+  const ownership = override ?? (toolName ? data.toolAnalyticsParameterOwnership.get(toolName) : undefined)
+  const isMissingCapabilityTool = toolName === resolveMissingCapabilityToolName(data.options)
+  return {
+    context: !isMissingCapabilityTool && isContextEnabled(data.options.context) && ownership?.context === true,
+    conversationId:
+      !isMissingCapabilityTool && data.options.enableConversationId === true && ownership?.conversationId === true,
+  }
+}
+
+function cloneRequestWithoutOwnedAnalyticsArguments(
+  request: MCPRequestLike,
+  ownership: AnalyticsParameterOwnership
+): MCPRequestLike {
+  const args = request.params?.arguments
+  const cleanedArgs = stripOwnedAnalyticsArguments(args, ownership)
+  if (cleanedArgs === args || !request.params) {
+    return request
+  }
+  return {
+    ...request,
+    params: {
+      ...request.params,
+      arguments: cleanedArgs as typeof request.params.arguments,
+    },
+  }
+}
+
 async function prepareToolCallEvent(
   server: MCPServerLike,
   data: MCPAnalyticsData,
@@ -136,6 +179,7 @@ async function prepareToolCallEvent(
   extra: CompatibleRequestHandlerExtra | undefined,
   startTime: Date,
   conversation: ConversationIdResolution,
+  ownership: AnalyticsParameterOwnership,
   eventType: MCPAnalyticsEventType
 ): Promise<McpEvent | null> {
   try {
@@ -159,10 +203,10 @@ async function prepareToolCallEvent(
     stampMetaClientInfo(event, request)
 
     await applyResolvedMetadata(event, data, request, extra)
-    setEventIntent(event, await resolveToolCallIntent(data, request, extra))
+    setEventIntent(event, await resolveToolCallIntent(data, request, ownership.context, extra))
     return event
   } catch (error) {
-    log(
+    data.logger(
       `Warning: PostHog MCP analytics instrumentation failed for tool ${request.params?.name}, the tool will still run - ${error}`
     )
     return null
@@ -196,6 +240,7 @@ function publishSuccessfulToolEvent(
   event: McpEvent | null,
   result: unknown,
   startTime: Date,
+  logger: LoggerFn,
   takeCapturedError?: () => unknown
 ): void {
   if (!event) {
@@ -211,9 +256,9 @@ function publishSuccessfulToolEvent(
     }
     event.response = result
     event.duration = Date.now() - startTime.getTime()
-    captureEvent(server, event)
+    captureEvent(server, event, logger)
   } catch (error) {
-    log(`Warning: PostHog MCP analytics failed to publish tool event - ${error}`)
+    logger(`Warning: PostHog MCP analytics failed to publish tool event - ${error}`)
   }
 }
 
@@ -222,7 +267,8 @@ function publishFailedToolEvent(
   event: McpEvent | null,
   error: unknown,
   startTime: Date,
-  conversation: ConversationIdResolution
+  conversation: ConversationIdResolution,
+  logger: LoggerFn
 ): void {
   if (!event) {
     return
@@ -234,9 +280,9 @@ function publishFailedToolEvent(
     event.isError = true
     event.error = captureException(error)
     event.duration = Date.now() - startTime.getTime()
-    captureEvent(server, event)
+    captureEvent(server, event, logger)
   } catch (publishError) {
-    log(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`)
+    logger(`Warning: PostHog MCP analytics failed to publish failed tool event - ${publishError}`)
   }
 }
 
@@ -292,7 +338,8 @@ export async function handleListToolsRequest(
   server: MCPServerLike,
   originalListToolsHandler: MCPRequestHandler,
   request: MCPRequestLike,
-  extra?: CompatibleRequestHandlerExtra
+  extra: CompatibleRequestHandlerExtra | undefined,
+  logger: LoggerFn
 ): Promise<{ tools: ListToolsResult['tools'] }> {
   const data = getServerTrackingData(server)
   const startTime = new Date()
@@ -308,23 +355,23 @@ export async function handleListToolsRequest(
     await applyResolvedMetadata(event, data, request, extra)
   }
 
-  const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event)
+  const tools = await getTracedToolsList(server, originalListToolsHandler, request, extra, event, logger)
 
   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 { tools }
   }
 
   if (tools.length === 0) {
-    log(
+    data.logger(
       'Warning: No tools found in the original list. This is likely due to the tools not being registered before PostHog MCP analytics.instrument().'
     )
     event.error = captureException('No tools were sent to MCP client.')
     event.isError = true
     event.duration = Date.now() - startTime.getTime()
-    captureEvent(server, event)
+    captureEvent(server, event, data.logger)
     return { tools }
   }
 
@@ -332,10 +379,22 @@ export async function handleListToolsRequest(
   event.listedToolNames = collectListedToolNames(tools)
   event.isError = false
   event.duration = Date.now() - startTime.getTime()
-  captureEvent(server, event)
+  captureEvent(server, event, data.logger)
   return { tools }
 }
 
+function cacheToolAnalyticsParameterOwnership(
+  cache: Map<string, AnalyticsParameterOwnership>,
+  tools: ListToolsResult['tools']
+): void {
+  // Merge pages and concurrent enumerations; repeated tool names overwrite stale schemas.
+  for (const tool of tools) {
+    if (tool?.name) {
+      cache.set(tool.name, getAnalyticsParameterOwnership(tool.inputSchema))
+    }
+  }
+}
+
 function collectListedToolNames(tools: ListToolsResult['tools'] | undefined): string[] | undefined {
   if (!tools || tools.length === 0) {
     return
@@ -349,19 +408,24 @@ async function getTracedToolsList(
   originalListToolsHandler: MCPRequestHandler,
   request: MCPRequestLike,
   extra: CompatibleRequestHandlerExtra | undefined,
-  event: McpEvent
+  event: McpEvent,
+  logger: LoggerFn
 ): Promise<ListToolsResult['tools']> {
   try {
     const data = getServerTrackingData(server)
     const originalResponse = (await originalListToolsHandler(request, extra)) as ListToolsResult
     let tools = originalResponse.tools || []
 
+    if (data) {
+      cacheToolAnalyticsParameterOwnership(data.toolAnalyticsParameterOwnership, tools)
+    }
+
     if (data && isContextEnabled(data.options.context)) {
-      tools = addContextParameterToTools(tools, getContextDescription(data.options.context))
+      tools = addContextParameterToTools(tools, getContextDescription(data.options.context), data.logger)
     }
 
     if (data?.options.enableConversationId) {
-      tools = addConversationIdToTools(tools, resolveMissingCapabilityToolName(data.options))
+      tools = addConversationIdToTools(tools, resolveMissingCapabilityToolName(data.options), data.logger)
     }
 
     if (data?.options.reportMissing) {
@@ -379,13 +443,13 @@ async function getTracedToolsList(
 
     return tools
   } catch (error) {
-    log(
+    logger(
       `Warning: Original list tools handler failed, this suggests an error PostHog MCP analytics did not cause - ${error}`
     )
     event.error = captureException(error)
     event.isError = true
     event.duration = event.timestamp ? Date.now() - event.timestamp.getTime() : 0
-    captureEvent(server, event)
+    captureEvent(server, event, logger)
     throw error
   }
 }
@@ -481,7 +545,7 @@ function mintStatelessSessionOnInitialize(
     setServerTrackingData(server, data)
     return sessionId
   } catch (error) {
-    log(`Warning: PostHog MCP analytics failed to mint a stateless session id - ${error}`)
+    data.logger(`Warning: PostHog MCP analytics failed to mint a stateless session id - ${error}`)
     return undefined
   }
 }
@@ -511,7 +575,7 @@ function upgradeMintedTokenToNegotiated(
     })
     writeSessionIdToTransport(transport, token)
   } catch (error) {
-    log(`Warning: PostHog MCP analytics failed to upgrade the stateless session token - ${error}`)
+    data.logger(`Warning: PostHog MCP analytics failed to upgrade the stateless session token - ${error}`)
   }
 }
 
@@ -539,11 +603,12 @@ export async function handleInitializeRequest(
   server: MCPServerLike,
   originalInitializeHandler: MCPRequestHandler,
   request: MCPRequestLike,
-  extra?: CompatibleRequestHandlerExtra
+  extra: CompatibleRequestHandlerExtra | undefined,
+  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 originalInitializeHandler(request, extra)
@@ -580,7 +645,7 @@ export async function handleInitializeRequest(
   if (mintedSessionId) {
     upgradeMintedTokenToNegotiated(server, data, mintedSessionId, negotiatedProtocolVersion)
   }
-  captureEvent(server, event)
+  captureEvent(server, event, data.logger)
   return result
 }
 

package/src/extensions/intent.ts

@@ -11,7 +11,6 @@ import type {
   McpEvent,
 } from '../types'
 import { isContextEnabled } from './context-parameters'
-import { log } from './logger'
 
 interface ResolvedIntent {
   intent: string
@@ -45,7 +44,7 @@ async function runIntentFallback(
     const intent = normalizeIntent(await data.options.intentFallback(request, extra))
     return intent ? { intent, source: 'inferred' } : null
   } catch (error) {
-    log(`intentFallback callback error: ${error}`)
+    data.logger(`intentFallback callback error: ${error}`)
     return null
   }
 }
@@ -53,10 +52,16 @@ async function runIntentFallback(
 export async function resolveToolCallIntent(
   data: MCPAnalyticsData,
   request: MCPRequestLike,
+  analyticsOwnsContext: boolean,
   extra?: CompatibleRequestHandlerExtra
 ): Promise<ResolvedIntent | null> {
   const contextArgument = getContextArgument(request)
-  if (isContextEnabled(data.options.context) && request.params?.name !== 'get_more_tools' && contextArgument) {
+  if (
+    analyticsOwnsContext &&
+    isContextEnabled(data.options.context) &&
+    request.params?.name !== 'get_more_tools' &&
+    contextArgument
+  ) {
     return { intent: contextArgument, source: 'context_parameter' }
   }
 

package/src/extensions/internal.ts

@@ -12,7 +12,6 @@ import type {
   UserIdentity,
 } from '../types'
 import { MCPAnalyticsEventType } from './event-types'
-import { log } from './logger'
 import { captureEvent } from './capture'
 import { stampMetaClientInfo } from './client-identity'
 
@@ -169,14 +168,16 @@ export async function handleIdentify(
       data.identifiedSessions.set(sessionId, mergedIdentity)
 
       if (shouldPublish) {
-        log(`Identified session ${sessionId} with identity: ${JSON.stringify(mergedIdentity)}`)
-        captureEvent(server, identifyEvent)
+        data.logger(`Identified session ${sessionId}`)
+        captureEvent(server, identifyEvent, data.logger)
       }
     } else {
-      log(`Warning: Supplied identify function returned null for session ${sessionId}`)
+      data.logger(`Warning: Supplied identify function returned null for session ${sessionId}`)
     }
   } catch (error) {
-    log(`Error: User supplied identify function threw an error while identifying session ${sessionId} - ${error}`)
+    data.logger(
+      `Error: User supplied identify function threw an error while identifying session ${sessionId} - ${error}`
+    )
   }
 }
 
@@ -196,7 +197,7 @@ export async function resolveEventProperties(
   try {
     return (await data.options.eventProperties(request, extra)) ?? null
   } catch (e) {
-    log(`eventProperties callback error: ${e}`)
+    data.logger(`eventProperties callback error: ${e}`)
     return null
   }
 }

package/src/extensions/logger.ts

@@ -8,10 +8,11 @@
  *
  * MCP servers running over the STDIO transport use stdout/stderr to exchange
  * protocol messages, so we cannot use the default `console.log`. We accept a
- * `logger` option on the public API; when omitted, log calls are silently
- * dropped. Errors that affect tracking should still be observable in apps that
- * want them, so the consumer can plug in any function (e.g. `console.error`
- * for non-STDIO transports, a file logger, etc.).
+ * `logger` option on the public API or the legacy logger configured through
+ * `setLogger`; when neither is configured, log calls are silently dropped.
+ * Errors that affect tracking should still be observable in apps that want
+ * them, so the consumer can plug in any function (e.g. `console.error` for
+ * non-STDIO transports, a file logger, etc.).
  */
 export type LoggerFn = (message: string) => void
 
@@ -21,12 +22,26 @@ export function setLogger(logger: LoggerFn | undefined): void {
   activeLogger = logger
 }
 
-export function log(message: string): void {
-  if (activeLogger) {
+function writeLog(logger: LoggerFn | undefined, message: string): void {
+  if (logger) {
     try {
-      activeLogger(message)
+      logger(message)
     } catch {
       // never let logging blow up the tracking pipeline
     }
   }
 }
+
+/**
+ * Creates a safe logger for one instrumented server. A server-specific logger
+ * remains isolated, while an omitted logger preserves the legacy `setLogger`
+ * fallback.
+ */
+export function createLogger(logger: LoggerFn | undefined): LoggerFn {
+  return logger ? (message) => writeLog(logger, message) : log
+}
+
+/** Logs through the legacy module-level logger configured by {@link setLogger}. */
+export function log(message: string): void {
+  writeLog(activeLogger, message)
+}

package/src/extensions/sink.ts

@@ -7,7 +7,7 @@ import type { PostHog } from 'posthog-node'
 import { uuidv7 } from '@posthog/core'
 
 import type { BeforeSendFn, Event, McpEvent } from '../types'
-import { log } from './logger'
+import { log, type LoggerFn } from './logger'
 import { type PostHogCaptureEvent, buildPostHogCaptureEvents } from './posthog-events'
 import { newPrefixedId } from './ids'
 import { sanitizeEvent } from './sanitization'
@@ -33,21 +33,22 @@ export interface McpCaptureOptions {
  */
 export async function processMcpEvent(
   event: McpEvent,
-  options: McpCaptureOptions
+  options: McpCaptureOptions,
+  logger: LoggerFn = log
 ): Promise<{ event: Event; captures: PostHogCaptureEvent[] } | null> {
   let processed: McpEvent = event
 
   try {
     processed = sanitizeEvent(processed)
   } catch (err) {
-    log(`Failed to sanitize event: ${err}`)
+    logger(`Failed to sanitize event: ${err}`)
     return null
   }
 
   try {
     processed = truncateEvent(processed)
   } catch (err) {
-    log(`Failed to truncate event: ${err}`)
+    logger(`Failed to truncate event: ${err}`)
     return null
   }
 
@@ -58,7 +59,7 @@ export async function processMcpEvent(
     enableExceptionAutocapture: options.enableExceptionAutocapture,
   })
 
-  const captures = await applyBeforeSend(built, options.beforeSend)
+  const captures = await applyBeforeSend(built, options.beforeSend, logger)
 
   return { event: fullEvent, captures }
 }
@@ -69,7 +70,8 @@ export async function processMcpEvent(
  */
 async function applyBeforeSend(
   captures: PostHogCaptureEvent[],
-  beforeSend: BeforeSendFn | undefined
+  beforeSend: BeforeSendFn | undefined,
+  logger: LoggerFn
 ): Promise<PostHogCaptureEvent[]> {
   if (!beforeSend) {
     return captures
@@ -83,7 +85,7 @@ async function applyBeforeSend(
         kept.push(result)
       }
     } catch (err) {
-      log(`beforeSend threw for event ${capture.event}; dropping it: ${err}`)
+      logger(`beforeSend threw for event ${capture.event}; dropping it: ${err}`)
     }
   }
   return kept
@@ -99,7 +101,10 @@ async function applyBeforeSend(
  * `@posthog/ai`).
  */
 export class McpEventSink {
-  constructor(private readonly posthog: PostHog) {}
+  constructor(
+    private readonly posthog: PostHog,
+    private readonly logger: LoggerFn = log
+  ) {}
 
   /**
    * Push an MCP event through the pipeline (sanitize → truncate → fan out →
@@ -107,7 +112,7 @@ export class McpEventSink {
    * dropped, never re-thrown into tool code.
    */
   async capture(event: McpEvent, options: McpCaptureOptions): Promise<void> {
-    const result = await processMcpEvent(event, options)
+    const result = await processMcpEvent(event, options, this.logger)
     if (!result) {
       return
     }
@@ -132,13 +137,13 @@ export class McpEventSink {
           uuid: uuidv7(),
         })
       }
-      log(
+      this.logger(
         `Captured PostHog event ${fullEvent.id} | ${fullEvent.eventType} | ${fullEvent.duration} ms | ${
-          fullEvent.identifyActorGivenId || 'anonymous'
+          fullEvent.identifyActorGivenId ? 'identified' : 'anonymous'
         }`
       )
     } catch (err) {
-      log(`Failed to capture PostHog event ${fullEvent.id}: ${err}`)
+      this.logger(`Failed to capture PostHog event ${fullEvent.id}: ${err}`)
     }
   }
 }

package/src/extensions/tools.ts

@@ -4,7 +4,7 @@
 // Licensed under the MIT License: https://github.com/agentcathq/agentcat-typescript-sdk/blob/main/LICENSE
 
 import { type CallToolResult, type ListToolsResult } from '@modelcontextprotocol/sdk/types.js'
-import { log } from './logger'
+import { log, type LoggerFn } from './logger'
 
 export const GET_MORE_TOOLS_NAME = 'get_more_tools' as const
 
@@ -67,7 +67,7 @@ export function getMoreToolsResult(): CallToolResult {
   }
 }
 
-export function handleReportMissing(args: { context: string }): CallToolResult {
-  log(`Missing tool reported: ${JSON.stringify(args)}`)
+export function handleReportMissing(args: { context: string }, logger: LoggerFn = log): CallToolResult {
+  logger(`Missing tool reported: ${JSON.stringify(args)}`)
   return getMoreToolsResult()
 }