/**

* Discord Bot API implementation with session threading support

*/

interface DiscordMessage {

id: string;

channel_id: string;

content: string;

timestamp: string;

thread?: {

id: string;

name: string;

};

}

interface DiscordThread {

id: string;

name: string;

parent_id: string;

}

export async function sendToDiscordWebhook(data: {

message: string;

username?: string;

metadata?: {

sessionId?: string;

messageNumber?: number;

pathname?: string;

timestamp?: string;

userAgent?: string;

messageType?: string;

timeOnPage?: number;

isFollowUp?: boolean;

};

}) {

const botToken = process.env.DISCORD_BOT_TOKEN;

const channelId = process.env.DISCORD_CHANNEL_ID;

if (!botToken || !channelId) {

console.warn('Discord bot token or channel ID not configured');

return;

}

try {

const { message, metadata } = data;

// Format message with clean text structure

const sessionPrefix = metadata?.sessionId ? metadata.sessionId.slice(-8) : 'unknown';

const messageNumber = metadata?.messageNumber || 1;

const messageType = metadata?.messageType === 'starter-prompt' ? '🟢' : '🔵';

const timeOnPage = metadata?.timeOnPage ? formatTime(metadata.timeOnPage) : 'N/A';

const browserInfo = extractBrowserInfo(metadata?.userAgent || '');

const page = formatPagePath(metadata?.pathname || '/');

// Check if an existing thread exists for this session

const existingThreadId = await findExistingThread(channelId, sessionPrefix);

if (existingThreadId) {

// Send to existing thread

await sendToThread(existingThreadId, message, {

messageNumber,

messageType,

page,

timeOnPage,

browserInfo

});

} else {

// Create new thread for first message

await createNewThread(channelId, message, {

sessionPrefix,

messageNumber,

messageType,

page,

timeOnPage,

browserInfo

});

}

} catch (error) {

if (error instanceof TypeError) {

// Network errors, CORS issues, or malformed URLs

console.error('Network error sending message to Discord:', error.message);

} else if (error instanceof SyntaxError) {

// JSON parsing errors

console.error('JSON parsing error in Discord webhook:', error.message);

} else if (error instanceof Error) {

// General errors with message

console.error('Error sending message to Discord:', error.message);

} else {

// Unknown error types

console.error('Unknown error sending message to Discord:', error);

}

}

}

export async function sendLLMResponseToDiscord(data: {

response: string;

metadata?: {

sessionId?: string;

model?: string;

};

}) {

const botToken = process.env.DISCORD_BOT_TOKEN;

const channelId = process.env.DISCORD_CHANNEL_ID;

if (!botToken || !channelId) {

console.warn('Discord bot token or channel ID not configured');

return;

}

try {

const { response, metadata } = data;

const sessionId = metadata?.sessionId || 'unknown';

const sessionPrefix = sessionId.slice(-8);

// Find the existing thread for this session

const existingThreadId = await findExistingThread(channelId, sessionPrefix);

if (!existingThreadId) {

console.warn(`No thread found for session ${sessionId}`);

return;

}

await sendResponseToThread(existingThreadId, response, {

model: metadata?.model

});

} catch (error) {

if (error instanceof TypeError) {

// Network errors, CORS issues, or malformed URLs

console.error('Network error sending LLM response to Discord:', error.message);

} else if (error instanceof SyntaxError) {

// JSON parsing errors

console.error('JSON parsing error in Discord LLM response:', error.message);

} else if (error instanceof Error) {

// General errors with message

console.error('Error sending LLM response to Discord:', error.message);

} else {

// Unknown error types

console.error('Unknown error sending LLM response to Discord:', error);

}

}

}

async function findExistingThread(channelId: string, sessionPrefix: string): Promise<string | null> {

const botToken = process.env.DISCORD_BOT_TOKEN;

if (!botToken) {

return null;

}

try {

// Get recent messages from the channel to find existing threads

const response = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages?limit=50`, {

headers: {

'Authorization': `Bot ${botToken}`,

'Content-Type': 'application/json',

},

});

if (!response.ok) {

const errorText = await response.text();

console.error(`Failed to fetch recent messages (${response.status}):`, errorText);

return null;

}

const messages: DiscordMessage[] = await response.json();

// Look for a message that contains our session prefix and has an associated thread

for (const message of messages) {

if (message.content.includes(`\`${sessionPrefix}\``) && message.thread) {

console.log(`Found existing thread for session ${sessionPrefix}: ${message.thread.id}`);

return message.thread.id;

}

}

return null;

} catch (error) {

if (error instanceof TypeError) {

// Network errors, invalid URL, or connection issues

console.error('Network error finding existing thread:', error.message);

} else if (error instanceof SyntaxError) {

// JSON parsing errors from Discord API response

console.error('JSON parsing error in Discord API response:', error.message);

} else if (error instanceof Error) {

// General errors with message

console.error('Error finding existing thread:', error.message);

} else {

// Unknown error types

console.error('Unknown error finding existing thread:', error);

}

return null;

}

}

async function createNewThread(

channelId: string,

message: string,

context: {

sessionPrefix: string;

messageNumber: number;

messageType: string;

page: string;

timeOnPage: string;

browserInfo?: string;

}

): Promise<void> {

const botToken = process.env.DISCORD_BOT_TOKEN;

try {

// Clean, readable format

const initialMessage = `💬 ${message}

\`${context.sessionPrefix}\` ${context.messageType} • ${context.page} • Page time: ${context.timeOnPage}${context.browserInfo ? ` • ${context.browserInfo}` : ''}`;

const messageResponse = await fetch(`https://discord.com/api/v10/channels/${channelId}/messages`, {

method: 'POST',

headers: {

'Authorization': `Bot ${botToken}`,

'Content-Type': 'application/json',

},

body: JSON.stringify({

content: initialMessage,

}),

});

if (!messageResponse.ok) {

const errorText = await messageResponse.text();

console.error(`Failed to send initial message (${messageResponse.status}):`, errorText);

return;

}

const messageData: DiscordMessage = await messageResponse.json();

// Create a thread from this message

const threadName = `${context.sessionPrefix}: ${extractQuestionSummary(message)}`;

const threadResponse = await fetch(`https://discord.com/api/v10/channels/${messageData.channel_id}/messages/${messageData.id}/threads`, {

method: 'POST',

headers: {

'Authorization': `Bot ${botToken}`,

'Content-Type': 'application/json',

},

body: JSON.stringify({

name: threadName.slice(0, 100), // Discord thread names have a 100 character limit

auto_archive_duration: 1440, // 24 hours

}),

});

if (!threadResponse.ok) {

const errorText = await threadResponse.text();

console.error(`Failed to create thread (${threadResponse.status}):`, errorText);

return;

}

const threadData: DiscordThread = await threadResponse.json();

console.log(`Created new thread: ${threadData.name} (${threadData.id})`);

} catch (error) {

if (error instanceof TypeError) {

// Network errors, invalid URL, or connection issues

console.error('Network error creating new thread:', error.message);

} else if (error instanceof SyntaxError) {

// JSON parsing errors from Discord API response

console.error('JSON parsing error creating thread:', error.message);

} else if (error instanceof Error) {

// General errors with message

console.error('Error creating thread:', error.message);

} else {

// Unknown error types

console.error('Unknown error creating thread:', error);

}

}

}

async function sendToThread(

threadId: string,

message: string,

context: {

messageNumber: number;

messageType: string;

page: string;

timeOnPage: string;

browserInfo?: string;

}

): Promise<void> {

const botToken = process.env.DISCORD_BOT_TOKEN;

try {

// Clean follow-up format

const formattedMessage = `🔄 **${message}**

${context.messageType} • ${context.page} • Page time: ${context.timeOnPage}${context.browserInfo ? ` • ${context.browserInfo}` : ''}`;

const response = await fetch(`https://discord.com/api/v10/channels/${threadId}/messages`, {

method: 'POST',

headers: {

'Authorization': `Bot ${botToken}`,

'Content-Type': 'application/json',

},

body: JSON.stringify({

content: formattedMessage,

}),

});

if (!response.ok) {

const errorText = await response.text();

console.error(`Failed to send message to thread (${response.status}):`, errorText);

// If thread doesn't exist anymore, log it but continue

if (response.status === 404) {

console.warn(`Thread ${threadId} no longer exists`);

}

} else {

console.log(`Sent follow-up message to thread ${threadId}`);

}

} catch (error) {

if (error instanceof TypeError) {

// Network errors, invalid URL, or connection issues

console.error('Network error sending message to thread:', error.message);

} else if (error instanceof SyntaxError) {

// JSON parsing errors

console.error('JSON parsing error sending to thread:', error.message);

} else if (error instanceof Error) {

// General errors with message

console.error('Error sending message to thread:', error.message);

} else {

// Unknown error types

console.error('Unknown error sending message to thread:', error);

}

}

}

async function sendResponseToThread(

threadId: string,

response: string,

context: {

model?: string;

}

): Promise<void> {

const botToken = process.env.DISCORD_BOT_TOKEN;

try {

const model = context.model || 'N/A';

// Truncate response if too long for Discord (2000 char limit)

const truncatedResponse = response.length > 1500 ? response.slice(0, 1500) + '...' : response;

const formattedResponse = `🤖 **AI Response**

\`\`\`

${truncatedResponse}

\`\`\`

${model}`;

const discordResponse = await fetch(`https://discord.com/api/v10/channels/${threadId}/messages`, {

method: 'POST',

headers: {

'Authorization': `Bot ${botToken}`,

'Content-Type': 'application/json',

},

body: JSON.stringify({

content: formattedResponse,

}),

});

if (!discordResponse.ok) {

const errorText = await discordResponse.text();

console.error(`Failed to send response to thread (${discordResponse.status}):`, errorText);

// If thread doesn't exist anymore, log it but continue

if (discordResponse.status === 404) {

console.warn(`Thread ${threadId} no longer exists for AI response`);

}

} else {

console.log(`Sent AI response to thread ${threadId}`);

}

} catch (error) {

if (error instanceof TypeError) {

// Network errors, invalid URL, or connection issues

console.error('Network error sending response to thread:', error.message);

} else if (error instanceof SyntaxError) {

// JSON parsing errors

console.error('JSON parsing error sending response to thread:', error.message);

} else if (error instanceof Error) {

// General errors with message

console.error('Error sending response to thread:', error.message);

} else {

// Unknown error types

console.error('Unknown error sending response to thread:', error);

}

}

}

function extractQuestionSummary(message: string): string {

// Extract first few words of the question for thread naming

const words = message.split(' ').slice(0, 6).join(' ');

return words.length > 40 ? words.slice(0, 37) + '...' : words;

}

function formatPagePath(pathname: string): string {

// Simplify common paths for better readability

if (pathname === '/') return 'Home';

if (pathname.startsWith('/docs/')) {

const path = pathname.replace('/docs/', '');

if (path === '') return 'Docs';

// Show only the last part of the path for brevity

const parts = path.split('/');

return parts[parts.length - 1] || 'Docs';

}

return pathname.length > 20 ? '...' + pathname.slice(-17) : pathname;

}

function formatTime(seconds: number): string {

if (seconds < 60) return `${seconds}s`;

if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;

return `${Math.floor(seconds / 3600)}h`;

}

/**

* Extract browser and OS info from user agent

*/

function extractBrowserInfo(userAgent: string): string | undefined {

if (!userAgent) return undefined;

// Browser detection patterns (order matters - Chrome must come before Safari)

const browserPatterns = [

{ pattern: 'Edge/', name: 'Edge' },

{ pattern: 'Chrome/', name: 'Chrome' },

{ pattern: 'Firefox/', name: 'Firefox' },

{ pattern: 'Safari/', name: 'Safari' },

];

// OS detection patterns

const osPatterns = [

{ pattern: 'Windows NT', name: 'Windows' },

{ pattern: 'Mac OS X', name: 'macOS' },

{ pattern: 'iPhone', name: 'iOS' },

{ pattern: 'iPad', name: 'iOS' },

{ pattern: 'Android', name: 'Android' },

{ pattern: 'Linux', name: 'Linux' },

];

// Find browser

const browser = browserPatterns.find(({ pattern }) => userAgent.includes(pattern))?.name || 'Unknown';

// Find OS

const os = osPatterns.find(({ pattern }) => userAgent.includes(pattern))?.name || 'Unknown';

return `${browser} on ${os}`;

}