@posthog/mcp 0.0.9 → 0.1.16

package/src/extensions/mcp-payloads.ts

@@ -0,0 +1,98 @@
+const CONTEXT_ARGUMENT_NAME = 'context'
+const REDACTED_VALUE = '[redacted]'
+const BASE64_PATTERN = /^[A-Za-z0-9+/\n\r]+=*$/
+const SIZE_GATE = 10_240
+const POSTHOG_TOKEN_PATTERN = /\bph[a-z]_[A-Za-z0-9_-]{20,}\b/g
+const SENSITIVE_KEY_PATTERN =
+  /^(authorization|cookie|set-cookie|x-api-key|api[-_]?key|api[-_]?token|access[-_]?token|refresh[-_]?token|token|password|secret|client[-_]?secret|private[-_]?key)$/i
+
+type JsonRecord = Record<string, unknown>
+
+function isRecord(value: unknown): value is JsonRecord {
+  return !!value && typeof value === 'object' && !Array.isArray(value)
+}
+
+function shouldRedactKey(key: string): boolean {
+  return SENSITIVE_KEY_PATTERN.test(key)
+}
+
+function sanitizeString(value: string): string {
+  if (value.length >= SIZE_GATE && BASE64_PATTERN.test(value)) {
+    return '[binary data redacted - not supported by PostHog MCP analytics]'
+  }
+  return value.replace(POSTHOG_TOKEN_PATTERN, REDACTED_VALUE)
+}
+
+export function sanitizeCapturedValue(value: unknown): unknown {
+  if (value == null) {
+    return value
+  }
+
+  if (typeof value === 'string') {
+    return sanitizeString(value)
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(sanitizeCapturedValue)
+  }
+
+  if (value instanceof Date) {
+    return value
+  }
+
+  if (typeof value !== 'object') {
+    return value
+  }
+
+  const result: JsonRecord = {}
+  for (const [key, nestedValue] of Object.entries(value)) {
+    result[key] = shouldRedactKey(key) ? REDACTED_VALUE : sanitizeCapturedValue(nestedValue)
+  }
+  return result
+}
+
+function buildCapturedMcpArguments(argumentsValue: unknown): unknown {
+  if (!isRecord(argumentsValue)) {
+    return sanitizeCapturedValue(argumentsValue)
+  }
+
+  const capturedArguments: JsonRecord = {}
+  for (const [key, value] of Object.entries(argumentsValue)) {
+    if (key === CONTEXT_ARGUMENT_NAME) {
+      continue
+    }
+    capturedArguments[key] = sanitizeCapturedValue(value)
+  }
+  return capturedArguments
+}
+
+function buildCapturedMcpParams(params: unknown): unknown {
+  if (!isRecord(params)) {
+    return sanitizeCapturedValue(params)
+  }
+
+  const capturedParams: JsonRecord = {}
+  for (const [key, value] of Object.entries(params)) {
+    capturedParams[key] = key === 'arguments' ? buildCapturedMcpArguments(value) : sanitizeCapturedValue(value)
+  }
+  return capturedParams
+}
+
+export function buildCapturedMcpParameters(request: unknown): JsonRecord {
+  if (!isRecord(request)) {
+    return { request: sanitizeCapturedValue(request) }
+  }
+
+  const capturedRequest: JsonRecord = {}
+  for (const key of ['id', 'jsonrpc', 'method'] as const) {
+    if (key in request) {
+      capturedRequest[key] = sanitizeCapturedValue(request[key])
+    }
+  }
+
+  if ('params' in request) {
+    capturedRequest.params = buildCapturedMcpParams(request.params)
+  }
+
+  return { request: capturedRequest }
+}

package/src/extensions/mcp-sdk-compat.ts

@@ -0,0 +1,160 @@
+/**
+ * MCP SDK Compatibility Helpers
+ *
+ * Internal utilities for handling differences between MCP SDK versions.
+ * These helpers abstract away SDK-internal details like:
+ * - Tool callback/handler property names (changed in SDK 1.24)
+ * - Zod schema internal structures (v3 vs v4)
+ */
+
+import type { RegisteredTool, ToolCallback } from '../types'
+
+// --- Tool function property utilities for MCP SDK version compatibility ---
+// MCP SDK 1.23 and earlier use "callback", 1.24+ uses "handler"
+
+export type ToolFunctionKey = 'callback' | 'handler'
+
+/**
+ * Returns the tool function (callback/handler) from a RegisteredTool.
+ * Supports both MCP SDK 1.23- (callback) and 1.24+ (handler).
+ */
+export function getToolFunction(tool: RegisteredTool): ToolCallback {
+  if ('handler' in tool && typeof tool.handler === 'function') {
+    return tool.handler
+  }
+  if ('callback' in tool && typeof tool.callback === 'function') {
+    return tool.callback
+  }
+  throw new Error('Tool has neither callback nor handler property')
+}
+
+/**
+ * Returns the property key name used for the tool function ("callback" or "handler").
+ * This preserves the original property name when wrapping tools.
+ */
+export function getToolFunctionKey(tool: RegisteredTool): ToolFunctionKey {
+  if ('handler' in tool && typeof tool.handler === 'function') {
+    return 'handler'
+  }
+  return 'callback'
+}
+
+/**
+ * Returns true if the tool has a callback or handler property.
+ */
+export function hasToolFunction(tool: unknown): tool is RegisteredTool {
+  if (!tool || typeof tool !== 'object') {
+    return false
+  }
+  const t = tool as Record<string, unknown>
+  return ('handler' in t && typeof t.handler === 'function') || ('callback' in t && typeof t.callback === 'function')
+}
+
+/**
+ * Creates a new tool object with the wrapped function, preserving the original property name.
+ * This ensures MCP SDK 1.24+ gets back a tool with "handler" and 1.23- gets "callback".
+ */
+export function createWrappedTool(originalTool: RegisteredTool, wrappedFunction: ToolCallback): RegisteredTool {
+  const key = getToolFunctionKey(originalTool)
+  return {
+    ...originalTool,
+    [key]: wrappedFunction,
+  } as RegisteredTool
+}
+
+// --- Zod schema internal property helpers ---
+// These access internal properties to extract method names from MCP SDK schemas
+// No Zod import needed - we introspect the internal structure directly
+
+interface ZodV3Internal {
+  _def?: {
+    value?: unknown
+    values?: unknown[] // For enums - some Zod versions store literal values here
+    shape?: Record<string, unknown> | (() => Record<string, unknown>)
+  }
+  shape?: Record<string, unknown> | (() => Record<string, unknown>)
+}
+
+interface ZodV4Internal {
+  _zod?: {
+    def?: {
+      value?: unknown
+      values?: unknown[] // For enums - some Zod versions store literal values here
+      shape?: Record<string, unknown> | (() => Record<string, unknown>)
+    }
+  }
+}
+
+export function isZ4Schema(schema: unknown): boolean {
+  if (!schema || typeof schema !== 'object') {
+    return false
+  }
+  return !!(schema as ZodV4Internal)._zod
+}
+
+export function getObjectShape(schema: unknown): Record<string, unknown> | undefined {
+  if (!schema || typeof schema !== 'object') {
+    return
+  }
+
+  let rawShape: Record<string, unknown> | (() => Record<string, unknown>) | undefined
+
+  if (isZ4Schema(schema)) {
+    const v4Schema = schema as ZodV4Internal
+    rawShape = v4Schema._zod?.def?.shape
+  } else {
+    const v3Schema = schema as ZodV3Internal
+    // Try .shape first, then fall back to _def.shape (some v3 schema types store it there)
+    rawShape = v3Schema.shape ?? v3Schema._def?.shape
+  }
+
+  if (!rawShape) {
+    return
+  }
+
+  if (typeof rawShape === 'function') {
+    try {
+      return rawShape()
+    } catch {
+      return
+    }
+  }
+
+  return rawShape
+}
+
+export function getLiteralValue(schema: unknown): unknown {
+  if (!schema || typeof schema !== 'object') {
+    return
+  }
+
+  if (isZ4Schema(schema)) {
+    const v4Schema = schema as ZodV4Internal
+    const def = v4Schema._zod?.def
+    if (def?.value !== undefined) {
+      return def.value
+    }
+    // Fallback: values array (for enums)
+    if (Array.isArray(def?.values) && def.values.length > 0) {
+      return def.values[0]
+    }
+  } else {
+    const v3Schema = schema as ZodV3Internal
+    const def = v3Schema._def
+    if (def?.value !== undefined) {
+      return def.value
+    }
+    // Fallback: values array (for enums)
+    if (Array.isArray(def?.values) && def.values.length > 0) {
+      return def.values[0]
+    }
+  }
+
+  // Final fallback: direct .value property (some Zod versions)
+  const directValue = (schema as { value?: unknown }).value
+  if (directValue !== undefined) {
+    return directValue
+  }
+
+  return
+}

package/src/extensions/posthog-events.ts

@@ -0,0 +1,212 @@
+import type { Event } from '../types'
+import { POSTHOG_MCP_ANALYTICS_SOURCE, PostHogMCPAnalyticsEvent, PostHogMCPAnalyticsProperty } from './constants'
+import { MCPAnalyticsEventType } from './event-types'
+
+const BUILT_IN_EVENT_NAME_BY_TYPE = {
+  [MCPAnalyticsEventType.custom]: PostHogMCPAnalyticsEvent.Custom,
+  [MCPAnalyticsEventType.identify]: PostHogMCPAnalyticsEvent.Identify,
+  [MCPAnalyticsEventType.mcpMissingCapability]: PostHogMCPAnalyticsEvent.MissingCapability,
+  [MCPAnalyticsEventType.mcpInitialize]: PostHogMCPAnalyticsEvent.Initialize,
+  [MCPAnalyticsEventType.mcpPromptsGet]: PostHogMCPAnalyticsEvent.PromptGet,
+  [MCPAnalyticsEventType.mcpPromptsList]: PostHogMCPAnalyticsEvent.PromptsList,
+  [MCPAnalyticsEventType.mcpResourcesList]: PostHogMCPAnalyticsEvent.ResourcesList,
+  [MCPAnalyticsEventType.mcpResourcesRead]: PostHogMCPAnalyticsEvent.ResourceRead,
+  [MCPAnalyticsEventType.mcpToolsCall]: PostHogMCPAnalyticsEvent.ToolCall,
+  [MCPAnalyticsEventType.mcpToolsList]: PostHogMCPAnalyticsEvent.ToolsList,
+} satisfies Record<MCPAnalyticsEventType, PostHogMCPAnalyticsEvent>
+
+function getDistinctId(event: Event): string {
+  return event.identifyActorGivenId || event.sessionId || 'anonymous'
+}
+
+function getTimestamp(event: Event): string {
+  return event.timestamp ? event.timestamp.toISOString() : new Date().toISOString()
+}
+
+export interface PostHogCaptureEvent {
+  distinct_id: string
+  event: string
+  properties: Record<string, unknown>
+  timestamp: string
+  type: 'capture'
+}
+
+export interface BuildPostHogCaptureEventsOptions {
+  /** Whether to emit a `$exception` sibling alongside errored events. Defaults to `true`. */
+  enableExceptionAutocapture?: boolean
+}
+
+export function buildPostHogCaptureEvents(
+  event: Event,
+  options: BuildPostHogCaptureEventsOptions = {}
+): PostHogCaptureEvent[] {
+  const batch = [buildCaptureEvent(event)]
+
+  if (event.isError && event.error && options.enableExceptionAutocapture !== false) {
+    batch.push(buildExceptionEvent(event))
+  }
+
+  return batch
+}
+
+function buildCaptureEvent(event: Event): PostHogCaptureEvent {
+  const distinctId = getDistinctId(event)
+  const timestamp = getTimestamp(event)
+
+  const properties: Record<string, unknown> = {
+    [PostHogMCPAnalyticsProperty.SessionId]: event.sessionId,
+    [PostHogMCPAnalyticsProperty.Source]: POSTHOG_MCP_ANALYTICS_SOURCE,
+  }
+  addConversationIdProperty(event, properties)
+  addPersonProcessingProperty(event, properties)
+  addGroupsProperty(event, properties)
+
+  addCommonEventProperties(event, properties)
+  addCustomEventProperties(event, properties)
+
+  return {
+    event: event.eventName ?? BUILT_IN_EVENT_NAME_BY_TYPE[event.eventType],
+    distinct_id: distinctId,
+    properties,
+    timestamp,
+    type: 'capture',
+  }
+}
+
+function addConversationIdProperty(event: Event, properties: Record<string, unknown>): void {
+  if (event.conversationId !== undefined && event.conversationId !== '') {
+    properties[PostHogMCPAnalyticsProperty.ConversationId] = event.conversationId
+  }
+}
+
+function addGroupsProperty(event: Event, properties: Record<string, unknown>): void {
+  if (event.groups && Object.keys(event.groups).length > 0) {
+    properties.$groups = event.groups
+  }
+}
+
+/**
+ * Without a resolved identity the distinct id is just the session id, so
+ * processing a person profile would mint one anonymous person per session and
+ * inflate person counts. Opt out of person processing in that case (matching
+ * `@posthog/ai` / posthog-node). When an identity is present we keep person
+ * processing so `$set` lands on a real person.
+ */
+function addPersonProcessingProperty(event: Event, properties: Record<string, unknown>): void {
+  if (!event.identifyActorGivenId) {
+    properties.$process_person_profile = false
+  }
+}
+
+function addCommonEventProperties(event: Event, properties: Record<string, unknown>): void {
+  if (event.resourceName) {
+    properties[PostHogMCPAnalyticsProperty.ResourceName] = event.resourceName
+    if (event.eventType === MCPAnalyticsEventType.mcpToolsCall) {
+      properties[PostHogMCPAnalyticsProperty.ToolName] = event.resourceName
+    }
+  }
+  if (event.toolDescription && event.eventType === MCPAnalyticsEventType.mcpToolsCall) {
+    properties[PostHogMCPAnalyticsProperty.ToolDescription] = event.toolDescription
+  }
+  if (
+    event.listedToolNames &&
+    event.listedToolNames.length > 0 &&
+    event.eventType === MCPAnalyticsEventType.mcpToolsList
+  ) {
+    properties[PostHogMCPAnalyticsProperty.ListedToolNames] = event.listedToolNames
+  }
+  if (event.duration !== undefined) {
+    properties[PostHogMCPAnalyticsProperty.DurationMs] = event.duration
+  }
+  if (event.serverName) {
+    properties[PostHogMCPAnalyticsProperty.ServerName] = event.serverName
+  }
+  if (event.serverVersion) {
+    properties[PostHogMCPAnalyticsProperty.ServerVersion] = event.serverVersion
+  }
+  if (event.clientName) {
+    properties[PostHogMCPAnalyticsProperty.ClientName] = event.clientName
+  }
+  if (event.clientVersion) {
+    properties[PostHogMCPAnalyticsProperty.ClientVersion] = event.clientVersion
+  }
+  if (event.userIntent) {
+    properties[PostHogMCPAnalyticsProperty.Intent] = event.userIntent
+  }
+  if (event.userIntentSource) {
+    properties[PostHogMCPAnalyticsProperty.IntentSource] = event.userIntentSource
+  }
+  if (event.isError !== undefined) {
+    properties[PostHogMCPAnalyticsProperty.IsError] = event.isError
+  }
+
+  if (event.parameters !== undefined) {
+    properties[PostHogMCPAnalyticsProperty.Parameters] = event.parameters
+  }
+  if (event.response !== undefined) {
+    properties[PostHogMCPAnalyticsProperty.Response] = event.response
+  }
+
+  if (event.identifyActorData && Object.keys(event.identifyActorData).length > 0) {
+    // Person properties from `identify().properties` go straight to `$set`.
+    properties.$set = { ...event.identifyActorData }
+  }
+}
+
+function addCustomEventProperties(event: Event, properties: Record<string, unknown>): void {
+  if (event.properties) {
+    for (const [key, value] of Object.entries(event.properties)) {
+      properties[key] = value
+    }
+  }
+}
+
+function buildExceptionEvent(event: Event): PostHogCaptureEvent {
+  const distinctId = getDistinctId(event)
+  const timestamp = getTimestamp(event)
+
+  const properties: Record<string, unknown> = {
+    [PostHogMCPAnalyticsProperty.SessionId]: event.sessionId,
+  }
+  addConversationIdProperty(event, properties)
+  addPersonProcessingProperty(event, properties)
+  addGroupsProperty(event, properties)
+
+  if (event.error) {
+    // Spread the core `$exception_list` / `$exception_level` properties so MCP
+    // tool failures use the same error-tracking contract as every other SDK.
+    Object.assign(properties, event.error)
+  }
+
+  if (event.resourceName) {
+    properties[PostHogMCPAnalyticsProperty.ResourceName] = event.resourceName
+    if (event.eventType === MCPAnalyticsEventType.mcpToolsCall) {
+      properties[PostHogMCPAnalyticsProperty.ToolName] = event.resourceName
+    }
+  }
+  if (event.toolDescription && event.eventType === MCPAnalyticsEventType.mcpToolsCall) {
+    properties[PostHogMCPAnalyticsProperty.ToolDescription] = event.toolDescription
+  }
+  if (event.serverName) {
+    properties[PostHogMCPAnalyticsProperty.ServerName] = event.serverName
+  }
+  if (event.serverVersion) {
+    properties[PostHogMCPAnalyticsProperty.ServerVersion] = event.serverVersion
+  }
+  if (event.clientName) {
+    properties[PostHogMCPAnalyticsProperty.ClientName] = event.clientName
+  }
+  if (event.clientVersion) {
+    properties[PostHogMCPAnalyticsProperty.ClientVersion] = event.clientVersion
+  }
+
+  addCustomEventProperties(event, properties)
+
+  return {
+    event: PostHogMCPAnalyticsEvent.Exception,
+    distinct_id: distinctId,
+    properties,
+    timestamp,
+    type: 'capture',
+  }
+}

package/src/extensions/sanitization.ts

@@ -0,0 +1,121 @@
+import type { Event, McpEvent } from '../types'
+import { sanitizeCapturedValue } from './mcp-payloads'
+
+type SanitizedRecord = Record<string, unknown>
+
+function isRecord(value: unknown): value is SanitizedRecord {
+  return !!value && typeof value === 'object' && !Array.isArray(value)
+}
+
+/**
+ * Sanitizes an event by redacting non-text content blocks from responses
+ * and large base64-encoded strings from parameters.
+ *
+ * This is a synchronous operation that returns a new object without mutating the original.
+ * It should run after customer redaction in the event pipeline.
+ */
+export function sanitizeEvent<T extends Event | McpEvent>(event: T): T {
+  const result = { ...event }
+
+  if (result.response != null) {
+    result.response = sanitizeResponse(result.response)
+  }
+
+  if (result.parameters != null) {
+    result.parameters = sanitizeParameters(result.parameters)
+  }
+
+  return result
+}
+
+/**
+ * Sanitizes response content blocks by replacing non-text content types
+ * with informative redaction messages.
+ */
+function sanitizeResponse(response: unknown): unknown {
+  if (response == null || typeof response !== 'object') {
+    return sanitizeCapturedValue(response)
+  }
+
+  const sanitized = sanitizeCapturedValue(response)
+  if (!isRecord(sanitized)) {
+    return sanitized
+  }
+
+  const result: SanitizedRecord = { ...sanitized }
+  const content = result.content
+  if (Array.isArray(content)) {
+    result.content = content.map(sanitizeContentBlock)
+  }
+
+  if (result.structuredContent != null && typeof result.structuredContent === 'object') {
+    result.structuredContent = sanitizeCapturedValue(result.structuredContent)
+  }
+
+  return result
+}
+
+/**
+ * Sanitizes a single content block based on its type discriminator.
+ */
+function sanitizeContentBlock(block: unknown): unknown {
+  if (block == null || typeof block !== 'object') {
+    return block
+  }
+
+  if (!isRecord(block)) {
+    return block
+  }
+
+  switch (block.type) {
+    case 'text':
+      return sanitizeCapturedValue(block)
+
+    case 'image':
+      return {
+        type: 'text',
+        text: '[image content redacted - not supported by PostHog MCP analytics]',
+      }
+
+    case 'audio':
+      return {
+        type: 'text',
+        text: '[audio content redacted - not supported by PostHog MCP analytics]',
+      }
+
+    case 'resource':
+      return sanitizeResourceBlock(block)
+
+    case 'resource_link':
+      return sanitizeCapturedValue(block)
+
+    default:
+      return {
+        type: 'text',
+        text: `[unsupported content type "${block.type}" redacted - not supported by PostHog MCP analytics]`,
+      }
+  }
+}
+
+/**
+ * Sanitizes an embedded resource content block.
+ * BlobResourceContents (has `blob` field) are redacted.
+ * TextResourceContents (has `text` field) pass through.
+ */
+function sanitizeResourceBlock(block: SanitizedRecord): unknown {
+  if (isRecord(block.resource) && 'blob' in block.resource) {
+    return {
+      type: 'text',
+      text: '[binary resource content redacted - not supported by PostHog MCP analytics]',
+    }
+  }
+  return sanitizeCapturedValue(block)
+}
+
+/**
+ * Recursively scans parameters for large base64-encoded strings and replaces them.
+ * Uses a size gate (10KB) to avoid regex testing on small strings.
+ */
+function sanitizeParameters(obj: unknown): unknown {
+  return sanitizeCapturedValue(obj)
+}

package/src/extensions/session.ts

@@ -0,0 +1,117 @@
+import { version } from '../version'
+import type {
+  CompatibleRequestHandlerExtra,
+  MCPAnalyticsData,
+  MCPServerLike,
+  ServerClientInfoLike,
+  SessionInfo,
+} from '../types'
+import { INACTIVITY_TIMEOUT_IN_MINUTES } from './constants'
+import { deterministicPrefixedId, newPrefixedId } from './ids'
+import { getServerTrackingData, setServerTrackingData } from './internal'
+
+export function newSessionId(): string {
+  return newPrefixedId('ses')
+}
+
+/**
+ * Derives the SDK session id deterministically from the MCP sessionId, so the
+ * same MCP session correlates to one SDK session across server restarts.
+ */
+export function deriveSessionIdFromMCPSession(mcpSessionId: string): string {
+  return deterministicPrefixedId('ses', mcpSessionId)
+}
+
+/**
+ * Resolves the session id for a request, preferring the MCP protocol sessionId
+ * over an SDK-generated one so a transport-supplied session wins.
+ */
+export function getServerSessionId(server: MCPServerLike, extra?: CompatibleRequestHandlerExtra): string {
+  const data = getServerTrackingData(server)
+
+  if (!data) {
+    throw new Error('Server tracking data not found')
+  }
+
+  const mcpSessionId = extra?.sessionId
+
+  if (mcpSessionId) {
+    data.sessionId = deriveSessionIdFromMCPSession(mcpSessionId)
+    data.lastMcpSessionId = mcpSessionId
+    data.sessionSource = 'mcp'
+    setServerTrackingData(server, data)
+    setLastActivity(server)
+    return data.sessionId
+  }
+
+  // Once a session has been MCP-derived, keep that id even if a later request
+  // arrives without the MCP sessionId, so the session doesn't fragment.
+  if (data.sessionSource === 'mcp' && data.lastMcpSessionId) {
+    setLastActivity(server)
+    return data.sessionId
+  }
+
+  // SDK-generated sessions roll over after an inactivity timeout.
+  const now = Date.now()
+  const timeoutMs = INACTIVITY_TIMEOUT_IN_MINUTES * 60 * 1000
+  if (now - data.lastActivity.getTime() > timeoutMs) {
+    data.sessionId = newSessionId()
+    data.sessionSource = 'generated'
+    setServerTrackingData(server, data)
+  }
+  setLastActivity(server)
+
+  return data.sessionId
+}
+
+export function setLastActivity(server: MCPServerLike): void {
+  const data = getServerTrackingData(server)
+
+  if (!data) {
+    throw new Error('Server tracking data not found')
+  }
+
+  data.lastActivity = new Date()
+  setServerTrackingData(server, data)
+}
+
+/**
+ * Builds the session metadata stamped onto an event. The caller passes the
+ * session id resolved for *this* request so identity attribution can't be
+ * clobbered by a concurrent request mutating shared `data.sessionId`.
+ */
+export function getSessionInfo(
+  server: MCPServerLike,
+  data: MCPAnalyticsData | undefined,
+  sessionId?: string
+): SessionInfo {
+  let clientInfo: ServerClientInfoLike | undefined = {
+    name: undefined,
+    version: undefined,
+  }
+  if (!data?.sessionInfo.clientName) {
+    clientInfo = server.getClientVersion()
+  }
+  const actorInfo = data?.identifiedSessions.get(sessionId ?? data.sessionId)
+
+  const sessionInfo: SessionInfo = {
+    ipAddress: undefined, // grab from django
+    sdkLanguage: 'TypeScript', // hardcoded for now
+    sdkVersion: version,
+    serverName: server._serverInfo?.name,
+    serverVersion: server._serverInfo?.version,
+    clientName: clientInfo?.name,
+    clientVersion: clientInfo?.version,
+    identifyActorGivenId: actorInfo?.distinctId,
+    identifyActorData: actorInfo?.properties || {},
+    identifyActorGroups: actorInfo?.groups,
+  }
+
+  if (!data) {
+    return sessionInfo
+  }
+
+  data.sessionInfo = sessionInfo
+  setServerTrackingData(server, data)
+  return data.sessionInfo
+}