@od-oneapp/analytics 2026.1.1301

package/dist/ai-YMnynb-t.mjs

@@ -0,0 +1,3347 @@
+import { t as __exportAll } from "./chunk-DQk6qfdC.mjs";
+import { o as track } from "./emitters-6-nKo8i-.mjs";
+
+//#region src/shared/emitters/ai/types.ts
+const AI_EVENTS = {
+	BRANCH_CREATED: "AI Branch Created",
+	BRANCH_MERGED: "AI Branch Merged",
+	CONVERSATION_CONTINUED: "AI Conversation Continued",
+	CONVERSATION_DELETED: "AI Conversation Deleted",
+	CONVERSATION_ENDED: "AI Conversation Ended",
+	CONVERSATION_RESUMED: "AI Conversation Resumed",
+	CONVERSATION_STARTED: "AI Conversation Started",
+	MESSAGE_DELETED: "AI Message Deleted",
+	MESSAGE_EDITED: "AI Message Edited",
+	MESSAGE_RECEIVED: "AI Message Received",
+	MESSAGE_REGENERATED: "AI Message Regenerated",
+	MESSAGE_SENT: "AI Message Sent",
+	STOP_GENERATION: "AI Stop Generation",
+	STREAMING_CHUNK_RECEIVED: "AI Streaming Chunk Received",
+	CODE_DEBUGGED: "AI Code Debugged",
+	CODE_EDITED: "AI Code Edited",
+	CODE_EXECUTED: "AI Code Executed",
+	CODE_EXPLAINED: "AI Code Explained",
+	CODE_GENERATED: "AI Code Generated",
+	CODE_REFACTORED: "AI Code Refactored",
+	CODE_TRANSLATED: "AI Code Translated",
+	COMPLETION_GENERATED: "AI Completion Generated",
+	CONTENT_COPIED: "AI Content Copied",
+	CONTENT_DOWNLOADED: "AI Content Downloaded",
+	CONTENT_REWRITTEN: "AI Content Rewritten",
+	CONTENT_SHARED: "AI Content Shared",
+	DIFF_VIEWED: "AI Diff Viewed",
+	DOCUMENT_CREATED: "AI Document Created",
+	EMAIL_DRAFTED: "AI Email Drafted",
+	IMAGE_EDITED: "AI Image Edited",
+	IMAGE_GENERATED: "AI Image Generated",
+	IMAGE_REVISED: "AI Image Revised",
+	INLINE_EDIT_APPLIED: "AI Inline Edit Applied",
+	OUTLINE_CREATED: "AI Outline Created",
+	REWRITE_GENERATED: "AI Rewrite Generated",
+	SUGGESTION_ACCEPTED: "AI Suggestion Accepted",
+	SUGGESTION_REJECTED: "AI Suggestion Rejected",
+	SUMMARY_GENERATED: "AI Summary Generated",
+	TEXT_GENERATED: "AI Text Generated",
+	TEXT_TRANSLATED: "AI Text Translated",
+	TRANSLATION_GENERATED: "AI Translation Generated",
+	BATCH_FILES_PROCESSED: "AI Batch Files Processed",
+	FILE_ANALYZED: "AI File Analyzed",
+	FILE_DELETED: "AI File Deleted",
+	FILE_DOWNLOADED: "AI File Downloaded",
+	FILE_PROCESSED: "AI File Processed",
+	FILE_PROCESSING_FAILED: "AI File Processing Failed",
+	FILE_REFERENCED: "AI File Referenced",
+	FILE_UPLOADED: "AI File Uploaded",
+	IMAGE_ANALYZED: "AI Image Analyzed",
+	IMAGE_UPLOADED: "AI Image Uploaded",
+	BROWSE_SESSION_STARTED: "AI Browse Session Started",
+	CITATION_ADDED: "AI Citation Added",
+	CITATION_PROVIDED: "AI Citation Provided",
+	EXTERNAL_SOURCE_ACCESSED: "AI External Source Accessed",
+	PAGE_CONTENT_FETCHED: "AI Page Content Fetched",
+	SEARCH_RESULTS_RANKED: "AI Search Results Ranked",
+	WEB_BROWSED: "AI Web Browsed",
+	WEB_SEARCH_PERFORMED: "AI Web Search Performed",
+	WEB_SEARCHED: "AI Web Searched",
+	API_CALLED: "AI API Called",
+	API_REQUEST_MADE: "AI API Request Made",
+	EXTENSION_USED: "AI Extension Used",
+	FUNCTION_EXECUTED: "AI Function Executed",
+	PLUGIN_ACTIVATED: "AI Plugin Activated",
+	PLUGIN_DISABLED: "AI Plugin Disabled",
+	PLUGIN_ENABLED: "AI Plugin Enabled",
+	PLUGIN_USED: "AI Plugin Used",
+	TOOL_CALL_COMPLETED: "AI Tool Call Completed",
+	TOOL_CALL_FAILED: "AI Tool Call Failed",
+	TOOL_CALL_STARTED: "AI Tool Call Started",
+	TOOL_CALLED: "AI Tool Called",
+	TOOL_FAILED: "AI Tool Failed",
+	CONTEXT_CLEARED: "AI Context Cleared",
+	CONTEXT_PRUNED: "AI Context Pruned",
+	CONTEXT_UPDATED: "AI Context Updated",
+	CONTEXT_WINDOW_UPDATED: "AI Context Window Updated",
+	CUSTOM_INSTRUCTIONS_CLEARED: "AI Custom Instructions Cleared",
+	CUSTOM_INSTRUCTIONS_CREATED: "AI Custom Instructions Created",
+	CUSTOM_INSTRUCTIONS_UPDATED: "AI Custom Instructions Updated",
+	EMBEDDING_GENERATED: "AI Embedding Generated",
+	KNOWLEDGE_BASE_QUERIED: "AI Knowledge Base Queried",
+	MEMORY_CLEARED: "AI Memory Cleared",
+	MEMORY_CREATED: "AI Memory Created",
+	MEMORY_DELETED: "AI Memory Deleted",
+	MEMORY_RECALLED: "AI Memory Recalled",
+	MEMORY_RETRIEVED: "AI Memory Retrieved",
+	MEMORY_STORED: "AI Memory Stored",
+	MEMORY_UPDATED: "AI Memory Updated",
+	PROJECT_CONTEXT_LOADED: "AI Project Context Loaded",
+	RAG_QUERY_EXECUTED: "AI RAG Query Executed",
+	AUDIO_INPUT_USED: "AI Audio Input Used",
+	AUDIO_OUTPUT_USED: "AI Audio Output Used",
+	CODE_COPIED: "AI Code Copied",
+	CONVERSATION_EXPORTED: "AI Conversation Exported",
+	MESSAGE_COPIED: "AI Message Copied",
+	MODEL_SELECTED: "AI Model Selected",
+	PARAMETER_ADJUSTED: "AI Parameter Adjusted",
+	STREAM_COMPLETED: "AI Stream Completed",
+	STREAM_STARTED: "AI Stream Started",
+	STREAMING_COMPLETED: "AI Streaming Completed",
+	STREAMING_STARTED: "AI Streaming Started",
+	CONVERSATION_ARCHIVED: "AI Conversation Archived",
+	CONVERSATION_DUPLICATED: "AI Conversation Duplicated",
+	CONVERSATION_MOVED: "AI Conversation Moved",
+	CONVERSATION_PINNED: "AI Conversation Pinned",
+	CONVERSATION_RENAMED: "AI Conversation Renamed",
+	CONVERSATION_SAVED: "AI Conversation Saved",
+	CONVERSATION_SEARCHED: "AI Conversation Searched",
+	FILTER_APPLIED: "AI Filter Applied",
+	FOLDER_CREATED: "AI Folder Created",
+	FOLDER_DELETED: "AI Folder Deleted",
+	FOLDER_RENAMED: "AI Folder Renamed",
+	SEARCH_PERFORMED: "AI Search Performed",
+	TAG_ADDED: "AI Tag Added",
+	TEMPLATE_CREATED: "AI Template Created",
+	TEMPLATE_DELETED: "AI Template Deleted",
+	TEMPLATE_USED: "AI Template Used",
+	COMMENT_ADDED: "AI Comment Added",
+	CONVERSATION_FORKED: "AI Conversation Forked",
+	CONVERSATION_SHARED: "AI Conversation Shared",
+	MEMBER_INVITED: "AI Member Invited",
+	PERMISSION_CHANGED: "AI Permission Changed",
+	TEAM_MEMBER_INVITED: "AI Team Member Invited",
+	TEAM_MEMBER_REMOVED: "AI Team Member Removed",
+	WORKSPACE_CREATED: "AI Workspace Created",
+	ARTIFACT_CREATED: "AI Artifact Created",
+	ARTIFACT_EDITED: "AI Artifact Edited",
+	ARTIFACT_EXECUTED: "AI Artifact Executed",
+	ARTIFACT_FORKED: "AI Artifact Forked",
+	ARTIFACT_PUBLISHED: "AI Artifact Published",
+	CANVAS_CLOSED: "AI Canvas Closed",
+	CANVAS_EDITED: "AI Canvas Edited",
+	CANVAS_OPENED: "AI Canvas Opened",
+	CANVAS_SAVED: "AI Canvas Saved",
+	LIVE_PREVIEW_TOGGLED: "AI Live Preview Toggled",
+	BUG_REPORTED: "AI Bug Reported",
+	FEATURE_REQUESTED: "AI Feature Requested",
+	FEEDBACK_NEGATIVE: "AI Feedback Negative",
+	FEEDBACK_POSITIVE: "AI Feedback Positive",
+	FEEDBACK_PROVIDED: "AI Feedback Provided",
+	HARMFUL_CONTENT_FLAGGED: "AI Harmful Content Flagged",
+	ISSUE_REPORTED: "AI Issue Reported",
+	QUALITY_ISSUE_REPORTED: "AI Quality Issue Reported",
+	RATING_PROVIDED: "AI Rating Provided",
+	RESPONSE_RATED: "AI Response Rated",
+	SAFETY_VIOLATION: "AI Safety Violation",
+	COST_TRACKED: "AI Cost Tracked",
+	ERROR_OCCURRED: "AI Error Occurred",
+	LATENCY_MEASURED: "AI Latency Measured",
+	MODEL_SWITCHED: "AI Model Switched",
+	PERFORMANCE_MEASURED: "AI Performance Measured",
+	RATE_LIMIT_HIT: "AI Rate Limit Hit",
+	SETTINGS_UPDATED: "AI Settings Updated",
+	TOKEN_LIMIT_REACHED: "AI Token Limit Reached",
+	TOKEN_USAGE_TRACKED: "AI Token Usage Tracked"
+};
+/**
+* AI SDK v6 event constants
+* For tracking AI SDK operations: agents, completions, tools, streaming, chat
+*/
+const AI_SDK_EVENTS = {
+	AGENT_CREATED: "ai_sdk_agent_created",
+	AGENT_EXECUTION_STARTED: "ai_sdk_agent_execution_started",
+	AGENT_EXECUTION_COMPLETED: "ai_sdk_agent_execution_completed",
+	AGENT_EXECUTION_FAILED: "ai_sdk_agent_execution_failed",
+	COMPLETION_REQUESTED: "ai_sdk_completion_requested",
+	COMPLETION_GENERATED: "ai_sdk_completion_generated",
+	COMPLETION_FAILED: "ai_sdk_completion_failed",
+	TOOL_CALL_STARTED: "ai_sdk_tool_call_started",
+	TOOL_CALL_COMPLETED: "ai_sdk_tool_call_completed",
+	TOOL_CALL_FAILED: "ai_sdk_tool_call_failed",
+	STREAM_STARTED: "ai_sdk_stream_started",
+	STREAM_CHUNK_RECEIVED: "ai_sdk_stream_chunk_received",
+	STREAM_COMPLETED: "ai_sdk_stream_completed",
+	STREAM_FAILED: "ai_sdk_stream_failed",
+	CHAT_SESSION_STARTED: "ai_sdk_chat_session_started",
+	CHAT_SESSION_ENDED: "ai_sdk_chat_session_ended",
+	CHAT_MESSAGE_SENT: "ai_sdk_chat_message_sent",
+	CHAT_MESSAGE_RECEIVED: "ai_sdk_chat_message_received",
+	CHATBOT_INTENT_DETECTED: "ai_sdk_chatbot_intent_detected",
+	CHATBOT_CART_ASSISTED: "ai_sdk_chatbot_cart_assisted",
+	CHATBOT_ORDER_ASSISTED: "ai_sdk_chatbot_order_assisted",
+	CHATBOT_PRODUCT_RECOMMENDED: "ai_sdk_chatbot_product_recommended",
+	TOKEN_USAGE_TRACKED: "ai_sdk_token_usage_tracked",
+	MULTI_STEP_STARTED: "ai_sdk_multi_step_started",
+	MULTI_STEP_PROGRESSED: "ai_sdk_multi_step_progressed",
+	MULTI_STEP_COMPLETED: "ai_sdk_multi_step_completed"
+};
+
+//#endregion
+//#region src/shared/emitters/ai/utils.ts
+/**
+* Remove undefined and null values from an object
+*/
+function cleanProperties(props) {
+	const cleaned = {};
+	for (const key in props) {
+		if (!Object.prototype.hasOwnProperty.call(props, key)) continue;
+		const value = props[key];
+		if (value !== void 0 && value !== null) cleaned[key] = value;
+	}
+	return cleaned;
+}
+/**
+* Validate that required properties are present
+*/
+function validateRequiredProperties(properties, required) {
+	const missing = [];
+	for (const key of required) if (properties[key] === void 0 || properties[key] === null) missing.push(String(key));
+	if (missing.length > 0) throw new Error(`Missing required properties: ${missing.join(", ")}`);
+}
+/**
+* Normalize base AI operation properties
+*/
+function normalizeBaseProperties(props) {
+	return {
+		model_id: props.model_id,
+		agent_id: props.agent_id,
+		agent_name: props.agent_name,
+		conversation_id: props.conversation_id,
+		session_id: props.session_id,
+		user_id: props.user_id,
+		operation_id: props.operation_id,
+		model_provider: props.model_provider
+	};
+}
+/**
+* Normalize token usage properties
+*/
+function normalizeTokenUsage(props) {
+	const normalized = {};
+	if (props.input_tokens !== void 0) normalized.input_tokens = Math.max(0, props.input_tokens);
+	if (props.output_tokens !== void 0) normalized.output_tokens = Math.max(0, props.output_tokens);
+	if (props.total_tokens !== void 0) normalized.total_tokens = Math.max(0, props.total_tokens);
+	else if (normalized.input_tokens !== void 0 && normalized.output_tokens !== void 0) normalized.total_tokens = normalized.input_tokens + normalized.output_tokens;
+	if (props.cost !== void 0) {
+		normalized.cost = Math.max(0, props.cost);
+		normalized.cost_currency = props.cost_currency ?? "USD";
+	}
+	return normalized;
+}
+/**
+* Normalize model configuration properties
+*/
+function normalizeModelConfig(props) {
+	const normalized = {};
+	if (props.temperature !== void 0) normalized.temperature = Math.max(0, Math.min(2, props.temperature));
+	if (props.max_tokens !== void 0) normalized.max_tokens = Math.max(1, props.max_tokens);
+	if (props.max_output_tokens !== void 0) normalized.max_output_tokens = Math.max(1, props.max_output_tokens);
+	if (props.top_p !== void 0) normalized.top_p = Math.max(0, Math.min(1, props.top_p));
+	if (props.frequency_penalty !== void 0) normalized.frequency_penalty = Math.max(-2, Math.min(2, props.frequency_penalty));
+	if (props.presence_penalty !== void 0) normalized.presence_penalty = Math.max(-2, Math.min(2, props.presence_penalty));
+	if (props.seed !== void 0) normalized.seed = props.seed;
+	if (props.stop_sequences !== void 0) normalized.stop_sequences = props.stop_sequences;
+	return normalized;
+}
+/**
+* Calculate cost based on token usage and model pricing
+*/
+function calculateCost(usage, pricing) {
+	let cost = 0;
+	if (usage.input_tokens && pricing.input_price_per_1k) cost += usage.input_tokens / 1e3 * pricing.input_price_per_1k;
+	if (usage.output_tokens && pricing.output_price_per_1k) cost += usage.output_tokens / 1e3 * pricing.output_price_per_1k;
+	return cost;
+}
+/**
+* Extract model provider from model ID
+*/
+function extractModelProvider(modelId) {
+	const lowercaseId = modelId.toLowerCase();
+	if (lowercaseId.includes("claude") || lowercaseId.includes("anthropic")) return "anthropic";
+	if (lowercaseId.includes("gpt") || lowercaseId.includes("openai")) return "openai";
+	if (lowercaseId.includes("gemini") || lowercaseId.includes("google")) return "google";
+	if (lowercaseId.includes("pplx") || lowercaseId.includes("perplexity")) return "perplexity";
+	return "other";
+}
+/**
+* Generate a unique operation ID
+*/
+function generateOperationId(prefix = "ai") {
+	return `${prefix}_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+}
+/**
+* Sanitize error message for tracking
+*/
+function sanitizeErrorMessage(error) {
+	return (typeof error === "string" ? error : error.message).replaceAll(/api[\s_\-]?keys?[\s:=]+[\w-]+/gi, "api_key=***").replaceAll(/tokens?[\s:=]+[\w-]+/gi, "token=***").replaceAll(/passwords?[\s:=]+[\w-]+/gi, "password=***").replaceAll(/secrets?[\s:=]+[\w-]+/gi, "secret=***").slice(0, 500);
+}
+/**
+* Calculate metrics for completion events
+*/
+function calculateCompletionMetrics(startTime, endTime, tokenUsage) {
+	const duration_ms = endTime - startTime;
+	const metrics = { duration_ms };
+	if (tokenUsage?.total_tokens && duration_ms > 0) metrics.tokens_per_second = tokenUsage.total_tokens / duration_ms * 1e3;
+	return metrics;
+}
+/**
+* Detect intent from chat message
+*/
+function detectIntent(message) {
+	const lowercase = message.toLowerCase();
+	for (const [intent, patterns] of Object.entries({
+		"order-tracking": [
+			"track",
+			"order status",
+			"shipping",
+			"delivery",
+			"where is my",
+			"when will",
+			"my order"
+		],
+		complaint: [
+			"disappointed",
+			"angry",
+			"frustrated",
+			"terrible",
+			"worst",
+			"complain",
+			"unhappy"
+		],
+		"returns-exchanges": [
+			"return",
+			"refund",
+			"exchange",
+			"cancel order",
+			"send back"
+		],
+		"product-search": [
+			"looking for",
+			"search for",
+			"find",
+			"show me",
+			"need",
+			"want to buy",
+			"shopping for"
+		],
+		"product-inquiry": [
+			"tell me about",
+			"details",
+			"specs",
+			"features",
+			"price",
+			"available",
+			"in stock"
+		],
+		"product-comparison": [
+			"compare",
+			"difference between",
+			"which is better",
+			"vs",
+			" or ",
+			"better than"
+		],
+		"cart-management": [
+			"add to cart",
+			"remove from cart",
+			"cart",
+			"shopping bag",
+			"my items"
+		],
+		"checkout-help": [
+			"checkout",
+			"payment",
+			"pay",
+			"purchase",
+			"buy now",
+			"complete order"
+		],
+		feedback: [
+			"review",
+			"feedback",
+			"rate",
+			"experience",
+			"satisfied"
+		]
+	})) if (patterns.some((pattern) => lowercase.includes(pattern))) return intent;
+	return "general-inquiry";
+}
+/**
+* Detect sentiment from message
+*/
+function detectSentiment(message) {
+	const lowercase = message.toLowerCase();
+	const positiveWords = [
+		"great",
+		"love",
+		"excellent",
+		"perfect",
+		"amazing",
+		"wonderful",
+		"awesome",
+		"fantastic",
+		"helpful",
+		"thank"
+	];
+	const negativeWords = [
+		"bad",
+		"terrible",
+		"awful",
+		"disappointed",
+		"angry",
+		"frustrated",
+		"annoyed",
+		"useless",
+		"worst",
+		"hate"
+	];
+	const positiveCount = positiveWords.filter((word) => lowercase.includes(word)).length;
+	const negativeCount = negativeWords.filter((word) => lowercase.includes(word)).length;
+	if (positiveCount > 0 && negativeCount > 0) return "mixed";
+	if (positiveCount > negativeCount) return "positive";
+	if (negativeCount > positiveCount) return "negative";
+	return "neutral";
+}
+/**
+* Truncate array to max length for tracking
+*/
+function truncateArray(arr, maxLength = 10) {
+	return arr.slice(0, maxLength);
+}
+/**
+* Safe JSON stringify for complex objects
+*/
+function safeStringify(obj, maxLength = 1e3) {
+	try {
+		if (obj === void 0) return "{}";
+		const str = JSON.stringify(obj);
+		return str.length > maxLength ? `${str.slice(0, Math.max(0, maxLength))}...` : str;
+	} catch {
+		return "[Unable to stringify]";
+	}
+}
+/**
+* Calculate conversation quality score
+*/
+function calculateQualityScore(metrics) {
+	let score = 100;
+	if (metrics.message_count < 3) score -= 20;
+	if (metrics.avg_response_time_ms && metrics.avg_response_time_ms > 3e3) score -= 10;
+	if (metrics.misunderstanding_count) score -= metrics.misunderstanding_count * 5;
+	if (metrics.clarification_count && metrics.clarification_count > 2) score -= (metrics.clarification_count - 2) * 3;
+	if (metrics.satisfaction_score && metrics.satisfaction_score >= 4) score += 10;
+	return Math.max(0, Math.min(100, score));
+}
+/**
+* Detect if message needs clarification
+*/
+function needsClarification(message) {
+	const lowercase = message.toLowerCase();
+	return [
+		"it",
+		"that one",
+		"this",
+		"them",
+		"those",
+		"something like",
+		"kind of",
+		"sort of",
+		"maybe",
+		"not sure"
+	].some((pattern) => lowercase.includes(pattern));
+}
+/**
+* Extract product mentions from message
+*/
+function extractProductMentions(message) {
+	const mentions = [];
+	const categories = [
+		"laptop",
+		"phone",
+		"tablet",
+		"watch",
+		"headphones",
+		"shoes",
+		"shirt",
+		"pants",
+		"dress",
+		"jacket"
+	];
+	const lowercase = message.toLowerCase();
+	for (const category of categories) if (lowercase.includes(category)) mentions.push(category);
+	return mentions;
+}
+/**
+* Alias for detectIntent for chatbot-specific contexts
+*/
+const detectChatbotIntent = detectIntent;
+
+//#endregion
+//#region src/shared/emitters/ai/track-ai.ts
+/**
+* @fileoverview AI tracking wrapper that integrates with the core emitter system
+* AI tracking wrapper that integrates with the core emitter system
+*/
+/**
+* Convert an AI event specification to a track payload
+*
+* @param eventSpec - The AI event specification
+* @param options - Optional emitter options
+* @returns Track payload ready to be sent to analytics providers
+*/
+function trackAI(eventSpec, options) {
+	const enrichedOptions = {
+		...options,
+		context: {
+			...options?.context,
+			...eventSpec.category && { traits: {
+				...options?.context?.traits,
+				event_category: eventSpec.category
+			} }
+		}
+	};
+	return track(eventSpec.name, eventSpec.properties, enrichedOptions);
+}
+/**
+* Helper to create a tracking function for a specific AI event
+* This allows for cleaner usage in applications
+*/
+function createAITracker(eventFactory) {
+	return (properties, options) => {
+		return trackAI(eventFactory(properties), options);
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ai/track-ai-sdk.ts
+/**
+* @fileoverview AI SDK v6 tracking wrapper that integrates with the core emitter system
+* AI SDK v6 tracking wrapper that integrates with the core emitter system
+*
+* Provides tracking for AI SDK v6 operations including:
+* - Agent execution
+* - Completions and text generation
+* - Tool calls and function calling
+* - Streaming responses
+* - Chat sessions
+* - E-commerce chatbot interactions
+*/
+/**
+* Convert an AI SDK event specification to a track payload
+*
+* @param eventSpec - The AI SDK event specification
+* @param options - Optional emitter options
+* @returns Track payload ready to be sent to analytics providers
+*/
+function trackAISDK(eventSpec, options) {
+	const enrichedOptions = {
+		...options,
+		context: {
+			...options?.context,
+			traits: {
+				...options?.context?.traits,
+				event_category: eventSpec.category
+			}
+		}
+	};
+	return track(eventSpec.name, eventSpec.properties, enrichedOptions);
+}
+/**
+* Helper to create a tracking function for a specific AI SDK event
+* This allows for cleaner usage in applications
+*
+* @param eventFactory - Function that creates an event spec from properties
+* @returns Tracking function for the specific event
+*/
+function createAISDKTracker(eventFactory) {
+	return (properties, options) => {
+		return trackAISDK(eventFactory(properties), options);
+	};
+}
+
+//#endregion
+//#region src/shared/emitters/ai/events/conversation.ts
+/**
+* @fileoverview Conversation & Messaging Events
+* Conversation & Messaging Events
+*
+* Core conversation lifecycle and message management for ChatGPT-style products.
+* Includes conversation start/end, messaging, regeneration, branching, and streaming.
+*/
+/**
+* Track conversation start
+*
+* @example
+* ```typescript
+* ai.CONVERSATION_STARTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   conversation_type: 'chat',
+* });
+* ```
+*/
+const CONVERSATION_STARTED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONVERSATION_STARTED,
+	category: "conversation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track conversation resume
+*
+* @example
+* ```typescript
+* ai.CONVERSATION_RESUMED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   last_active_timestamp: '2024-01-15T10:30:00Z',
+*   message_count: 15,
+* });
+* ```
+*/
+const CONVERSATION_RESUMED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONVERSATION_RESUMED,
+	category: "conversation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track conversation end
+*
+* @example
+* ```typescript
+* ai.CONVERSATION_ENDED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   end_reason: 'user-ended',
+*   duration_ms: 180000,
+*   message_count: 25,
+* });
+* ```
+*/
+const CONVERSATION_ENDED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONVERSATION_ENDED,
+	category: "conversation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track user message sent
+*
+* @example
+* ```typescript
+* ai.MESSAGE_SENT({
+*   conversation_id: 'conv_123',
+*   message_id: 'msg_456',
+*   model_id: 'gpt-4',
+*   message_role: 'user',
+*   message_length: 50,
+* });
+* ```
+*/
+const MESSAGE_SENT = createAITracker((properties) => ({
+	name: AI_EVENTS.MESSAGE_SENT,
+	category: "conversation",
+	properties,
+	requiredProperties: ["message_role"]
+}));
+/**
+* Track AI message received
+*
+* @example
+* ```typescript
+* ai.MESSAGE_RECEIVED({
+*   conversation_id: 'conv_123',
+*   message_id: 'msg_457',
+*   model_id: 'claude-3-5-sonnet',
+*   message_role: 'assistant',
+*   message_length: 250,
+*   response_time_ms: 850,
+*   finish_reason: 'stop',
+*   input_tokens: 450,
+*   output_tokens: 320,
+* });
+* ```
+*/
+const MESSAGE_RECEIVED = createAITracker((properties) => ({
+	name: AI_EVENTS.MESSAGE_RECEIVED,
+	category: "conversation",
+	properties,
+	requiredProperties: ["message_role"]
+}));
+/**
+* Track message regeneration
+*
+* @example
+* ```typescript
+* ai.MESSAGE_REGENERATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   original_message_id: 'msg_457',
+*   attempt_number: 2,
+*   reason: 'user-requested',
+*   temperature_adjusted: true,
+* });
+* ```
+*/
+const MESSAGE_REGENERATED = createAITracker((properties) => ({
+	name: AI_EVENTS.MESSAGE_REGENERATED,
+	category: "conversation",
+	properties,
+	requiredProperties: ["original_message_id"]
+}));
+/**
+* Track message edit
+*
+* @example
+* ```typescript
+* ai.MESSAGE_EDITED({
+*   conversation_id: 'conv_123',
+*   message_id: 'msg_456',
+*   model_id: 'claude-3-5-sonnet',
+*   edit_type: 'user-edit',
+*   original_length: 50,
+*   new_length: 75,
+* });
+* ```
+*/
+const MESSAGE_EDITED = createAITracker((properties) => ({
+	name: AI_EVENTS.MESSAGE_EDITED,
+	category: "conversation",
+	properties,
+	requiredProperties: ["message_role"]
+}));
+/**
+* Track message deletion
+*
+* @example
+* ```typescript
+* ai.MESSAGE_DELETED({
+*   conversation_id: 'conv_123',
+*   message_id: 'msg_458',
+*   model_id: 'gpt-4',
+*   message_role: 'assistant',
+*   deleted_by: 'user',
+* });
+* ```
+*/
+const MESSAGE_DELETED = createAITracker((properties) => ({
+	name: AI_EVENTS.MESSAGE_DELETED,
+	category: "conversation",
+	properties,
+	requiredProperties: ["message_role"]
+}));
+/**
+* Track conversation branch creation
+*
+* @example
+* ```typescript
+* ai.BRANCH_CREATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   branch_point_message_id: 'msg_457',
+*   original_conversation_id: 'conv_123',
+*   new_conversation_id: 'conv_124',
+*   reason: 'explore-alternative',
+* });
+* ```
+*/
+const BRANCH_CREATED = createAITracker((properties) => ({
+	name: AI_EVENTS.BRANCH_CREATED,
+	category: "conversation",
+	properties,
+	requiredProperties: [
+		"branch_point_message_id",
+		"new_conversation_id",
+		"original_conversation_id"
+	]
+}));
+/**
+* Track conversation branch merge
+*
+* @example
+* ```typescript
+* ai.BRANCH_MERGED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   branch_point_message_id: 'msg_457',
+*   original_conversation_id: 'conv_123',
+*   new_conversation_id: 'conv_124',
+*   merge_strategy: 'keep-both',
+* });
+* ```
+*/
+const BRANCH_MERGED = createAITracker((properties) => ({
+	name: AI_EVENTS.BRANCH_MERGED,
+	category: "conversation",
+	properties,
+	requiredProperties: [
+		"branch_point_message_id",
+		"new_conversation_id",
+		"original_conversation_id"
+	]
+}));
+/**
+* Track stop generation (user interrupts response)
+*
+* @example
+* ```typescript
+* ai.STOP_GENERATION({
+*   conversation_id: 'conv_123',
+*   message_id: 'msg_458',
+*   model_id: 'gpt-4',
+*   partial_length: 120,
+*   stop_reason: 'user-interrupted',
+*   tokens_used_at_stop: 150,
+* });
+* ```
+*/
+const STOP_GENERATION = createAITracker((properties) => ({
+	name: AI_EVENTS.STOP_GENERATION,
+	category: "conversation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track streaming start
+*
+* @example
+* ```typescript
+* ai.STREAMING_STARTED({
+*   conversation_id: 'conv_123',
+*   message_id: 'msg_459',
+*   model_id: 'claude-3-5-sonnet',
+*   stream_type: 'text',
+* });
+* ```
+*/
+const STREAMING_STARTED = createAITracker((properties) => ({
+	name: AI_EVENTS.STREAMING_STARTED,
+	category: "conversation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track streaming chunk received (sample, not every chunk)
+*
+* @example
+* ```typescript
+* // Sample every 10th chunk
+* if (chunkCount % 10 === 0) {
+*   ai.STREAMING_CHUNK_RECEIVED({
+*     conversation_id: 'conv_123',
+*     message_id: 'msg_459',
+*     model_id: 'gpt-4',
+*     stream_type: 'text',
+*     chunk_index: chunkCount,
+*     chunk_size_bytes: 256,
+*   });
+* }
+* ```
+*/
+const STREAMING_CHUNK_RECEIVED = createAITracker((properties) => ({
+	name: AI_EVENTS.STREAMING_CHUNK_RECEIVED,
+	category: "conversation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track streaming completion
+*
+* @example
+* ```typescript
+* ai.STREAMING_COMPLETED({
+*   conversation_id: 'conv_123',
+*   message_id: 'msg_459',
+*   model_id: 'claude-3-5-sonnet',
+*   stream_type: 'text',
+*   chunk_count: 45,
+*   total_bytes: 11520,
+*   stream_duration_ms: 3200,
+*   chunks_per_second: 14.06,
+* });
+* ```
+*/
+const STREAMING_COMPLETED = createAITracker((properties) => ({
+	name: AI_EVENTS.STREAMING_COMPLETED,
+	category: "conversation",
+	properties,
+	requiredProperties: []
+}));
+
+//#endregion
+//#region src/shared/emitters/ai/events/content-generation.ts
+/**
+* @fileoverview Content Generation Events
+* Content Generation Events
+*
+* All types of AI-generated content: code, images, summaries, translations, etc.
+* These track what the AI creates, not what users do with it.
+*/
+/**
+* Track code generation
+*
+* @example
+* ```typescript
+* ai.CODE_GENERATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   language: 'typescript',
+*   code_length: 450,
+*   code_type: 'function',
+*   has_explanation: true,
+*   has_tests: false,
+* });
+* ```
+*/
+const CODE_GENERATED = createAITracker((properties) => ({
+	name: AI_EVENTS.CODE_GENERATED,
+	category: "content-generation",
+	properties,
+	requiredProperties: ["task_type"]
+}));
+/**
+* Track code explanation
+*
+* @example
+* ```typescript
+* ai.CODE_EXPLAINED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   language: 'python',
+*   code_length: 200,
+*   explanation_length: 500,
+*   explanation_type: 'detailed',
+* });
+* ```
+*/
+const CODE_EXPLAINED = createAITracker((properties) => ({
+	name: AI_EVENTS.CODE_EXPLAINED,
+	category: "content-generation",
+	properties,
+	requiredProperties: ["task_type"]
+}));
+/**
+* Track code debugging assistance
+*
+* @example
+* ```typescript
+* ai.CODE_DEBUGGED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   language: 'javascript',
+*   code_length: 300,
+*   issues_found: 3,
+*   fixes_suggested: 3,
+* });
+* ```
+*/
+const CODE_DEBUGGED = createAITracker((properties) => ({
+	name: AI_EVENTS.CODE_DEBUGGED,
+	category: "content-generation",
+	properties,
+	requiredProperties: ["task_type"]
+}));
+/**
+* Track code refactoring suggestions
+*
+* @example
+* ```typescript
+* ai.CODE_REFACTORED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   language: 'typescript',
+*   code_length: 500,
+*   refactor_type: 'extract-function',
+*   improvements_suggested: 5,
+* });
+* ```
+*/
+const CODE_REFACTORED = createAITracker((properties) => ({
+	name: AI_EVENTS.CODE_REFACTORED,
+	category: "content-generation",
+	properties,
+	requiredProperties: ["task_type"]
+}));
+/**
+* Track code translation between languages
+*
+* @example
+* ```typescript
+* ai.CODE_TRANSLATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   language: 'typescript',
+*   code_length: 350,
+*   source_language: 'python',
+*   target_language: 'typescript',
+* });
+* ```
+*/
+const CODE_TRANSLATED = createAITracker((properties) => ({
+	name: AI_EVENTS.CODE_TRANSLATED,
+	category: "content-generation",
+	properties,
+	requiredProperties: ["task_type"]
+}));
+/**
+* Track image generation
+*
+* @example
+* ```typescript
+* ai.IMAGE_GENERATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'dall-e-3',
+*   image_type: 'generated',
+*   prompt_length: 80,
+*   image_format: 'png',
+*   image_size: '1024x1024',
+*   generation_time_ms: 5000,
+* });
+* ```
+*/
+const IMAGE_GENERATED = createAITracker((properties) => ({
+	name: AI_EVENTS.IMAGE_GENERATED,
+	category: "content-generation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track image editing
+*
+* @example
+* ```typescript
+* ai.IMAGE_EDITED({
+*   conversation_id: 'conv_123',
+*   model_id: 'dall-e-3',
+*   image_type: 'edited',
+*   edit_type: 'inpaint',
+*   prompt_length: 50,
+*   image_format: 'png',
+* });
+* ```
+*/
+const IMAGE_EDITED = createAITracker((properties) => ({
+	name: AI_EVENTS.IMAGE_EDITED,
+	category: "content-generation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track general text generation
+*
+* @example
+* ```typescript
+* ai.TEXT_GENERATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   content_type: 'article',
+*   content_length: 1500,
+*   content_format: 'markdown',
+* });
+* ```
+*/
+const TEXT_GENERATED = createAITracker((properties) => ({
+	name: AI_EVENTS.TEXT_GENERATED,
+	category: "content-generation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track summary generation
+*
+* @example
+* ```typescript
+* ai.SUMMARY_GENERATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   source_type: 'document',
+*   source_length: 5000,
+*   summary_length: 300,
+*   summary_type: 'bullet-points',
+*   compression_ratio: 16.7,
+* });
+* ```
+*/
+const SUMMARY_GENERATED = createAITracker((properties) => ({
+	name: AI_EVENTS.SUMMARY_GENERATED,
+	category: "content-generation",
+	properties,
+	requiredProperties: [
+		"input_length",
+		"output_length",
+		"summary_type"
+	]
+}));
+/**
+* Track text translation
+*
+* @example
+* ```typescript
+* ai.TRANSLATION_GENERATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   content_type: 'translation',
+*   content_length: 450,
+*   source_language: 'english',
+*   target_language: 'spanish',
+* });
+* ```
+*/
+const TRANSLATION_GENERATED = createAITracker((properties) => ({
+	name: AI_EVENTS.TRANSLATION_GENERATED,
+	category: "content-generation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track text completion
+*
+* @example
+* ```typescript
+* ai.COMPLETION_GENERATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   content_type: 'completion',
+*   content_length: 200,
+*   completion_type: 'sentence',
+* });
+* ```
+*/
+const COMPLETION_GENERATED = createAITracker((properties) => ({
+	name: AI_EVENTS.COMPLETION_GENERATED,
+	category: "content-generation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track content rewrite
+*
+* @example
+* ```typescript
+* ai.REWRITE_GENERATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   content_type: 'rewrite',
+*   content_length: 350,
+*   original_length: 300,
+*   rewrite_style: 'formal',
+* });
+* ```
+*/
+const REWRITE_GENERATED = createAITracker((properties) => ({
+	name: AI_EVENTS.REWRITE_GENERATED,
+	category: "content-generation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track email draft assistance
+*
+* @example
+* ```typescript
+* ai.EMAIL_DRAFTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   content_type: 'email',
+*   content_length: 400,
+*   email_type: 'professional',
+*   has_subject: true,
+* });
+* ```
+*/
+const EMAIL_DRAFTED = createAITracker((properties) => ({
+	name: AI_EVENTS.EMAIL_DRAFTED,
+	category: "content-generation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track document creation
+*
+* @example
+* ```typescript
+* ai.DOCUMENT_CREATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   content_type: 'document',
+*   content_length: 2500,
+*   content_format: 'markdown',
+*   document_type: 'report',
+* });
+* ```
+*/
+const DOCUMENT_CREATED = createAITracker((properties) => ({
+	name: AI_EVENTS.DOCUMENT_CREATED,
+	category: "content-generation",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track outline creation
+*
+* @example
+* ```typescript
+* ai.OUTLINE_CREATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   content_type: 'outline',
+*   content_length: 600,
+*   section_count: 8,
+*   outline_depth: 3,
+* });
+* ```
+*/
+const OUTLINE_CREATED = createAITracker((properties) => ({
+	name: AI_EVENTS.OUTLINE_CREATED,
+	category: "content-generation",
+	properties,
+	requiredProperties: []
+}));
+
+//#endregion
+//#region src/shared/emitters/ai/events/artifacts.ts
+/**
+* @fileoverview Artifacts & Canvas Events
+* Artifacts & Canvas Events
+*
+* Interactive artifacts and canvas mode features (Claude-style).
+* Track creation, editing, execution, and interaction with artifacts.
+*/
+/**
+* Track artifact creation
+*
+* @example
+* ```typescript
+* ai.ARTIFACT_CREATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   artifact_id: 'art_001',
+*   artifact_type: 'react-component',
+*   action: 'create',
+*   language: 'tsx',
+*   content_length: 850,
+* });
+* ```
+*/
+const ARTIFACT_CREATED = createAITracker((properties) => ({
+	name: AI_EVENTS.ARTIFACT_CREATED,
+	category: "artifacts",
+	properties,
+	requiredProperties: ["action", "artifact_type"]
+}));
+/**
+* Track artifact editing
+*
+* @example
+* ```typescript
+* ai.ARTIFACT_EDITED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   artifact_id: 'art_001',
+*   artifact_type: 'react-component',
+*   action: 'edit',
+*   version: 2,
+*   changes_description: 'Updated button styling',
+* });
+* ```
+*/
+const ARTIFACT_EDITED = createAITracker((properties) => ({
+	name: AI_EVENTS.ARTIFACT_EDITED,
+	category: "artifacts",
+	properties,
+	requiredProperties: ["action", "artifact_type"]
+}));
+/**
+* Track artifact execution
+*
+* @example
+* ```typescript
+* ai.ARTIFACT_EXECUTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   artifact_id: 'art_001',
+*   artifact_type: 'code',
+*   action: 'execute',
+*   execution_status: 'success',
+*   execution_time_ms: 150,
+* });
+* ```
+*/
+const ARTIFACT_EXECUTED = createAITracker((properties) => ({
+	name: AI_EVENTS.ARTIFACT_EXECUTED,
+	category: "artifacts",
+	properties,
+	requiredProperties: ["action", "artifact_type"]
+}));
+/**
+* Track artifact publishing
+*
+* @example
+* ```typescript
+* ai.ARTIFACT_PUBLISHED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   artifact_id: 'art_001',
+*   artifact_type: 'visualization',
+*   action: 'publish',
+*   visibility: 'public',
+*   publish_platform: 'web',
+* });
+* ```
+*/
+const ARTIFACT_PUBLISHED = createAITracker((properties) => ({
+	name: AI_EVENTS.ARTIFACT_PUBLISHED,
+	category: "artifacts",
+	properties,
+	requiredProperties: ["action", "artifact_type"]
+}));
+/**
+* Track artifact forking
+*
+* @example
+* ```typescript
+* ai.ARTIFACT_FORKED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   artifact_id: 'art_001',
+*   artifact_type: 'react-component',
+*   action: 'fork',
+*   new_artifact_id: 'art_002',
+*   fork_reason: 'experiment',
+* });
+* ```
+*/
+const ARTIFACT_FORKED = createAITracker((properties) => ({
+	name: AI_EVENTS.ARTIFACT_FORKED,
+	category: "artifacts",
+	properties,
+	requiredProperties: ["action", "artifact_type"]
+}));
+/**
+* Track canvas mode opened
+*
+* @example
+* ```typescript
+* ai.CANVAS_OPENED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   canvas_type: 'code',
+*   initial_content_length: 500,
+*   canvas_size: 'full-screen',
+* });
+* ```
+*/
+const CANVAS_OPENED = createAITracker((properties) => ({
+	name: AI_EVENTS.CANVAS_OPENED,
+	category: "artifacts",
+	properties,
+	requiredProperties: ["action"]
+}));
+/**
+* Track live preview toggle
+*
+* @example
+* ```typescript
+* ai.LIVE_PREVIEW_TOGGLED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-net',
+*   artifact_id: 'art_001',
+*   preview_enabled: true,
+*   preview_type: 'browser',
+* });
+* ```
+*/
+const LIVE_PREVIEW_TOGGLED = createAITracker((properties) => ({
+	name: AI_EVENTS.LIVE_PREVIEW_TOGGLED,
+	category: "artifacts",
+	properties,
+	requiredProperties: ["action"]
+}));
+
+//#endregion
+//#region src/shared/emitters/ai/events/product-features.ts
+/**
+* @fileoverview Additional AI Product Features
+* Additional AI Product Features
+*
+* Comprehensive tracking for all remaining AI product features:
+* - User interactions (copy, execute, download)
+* - Files & attachments
+* - Context & memory management
+* - Collaboration & sharing
+* - Workspace & organization
+* - Feedback & quality
+* - System & performance
+* - Tools & functions
+* - Search & citations
+*/
+/**
+* Track code copy action
+*
+* @example
+* ```typescript
+* ai.CODE_COPIED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   code_id: 'code_789',
+*   language: 'typescript',
+*   code_length: 450,
+* });
+* ```
+*/
+const CODE_COPIED = createAITracker((properties) => ({
+	name: AI_EVENTS.CODE_COPIED,
+	category: "user-interactions",
+	properties,
+	requiredProperties: ["task_type"]
+}));
+/**
+* Track code execution
+*
+* @example
+* ```typescript
+* ai.CODE_EXECUTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   code_id: 'code_789',
+*   language: 'typescript',
+*   execution_status: 'success',
+*   execution_time_ms: 120,
+* });
+* ```
+*/
+const CODE_EXECUTED = createAITracker((properties) => ({
+	name: AI_EVENTS.CODE_EXECUTED,
+	category: "user-interactions",
+	properties,
+	requiredProperties: ["task_type"]
+}));
+/**
+* Track general content copy
+*
+* @example
+* ```typescript
+* ai.CONTENT_COPIED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   content_id: 'content_456',
+*   content_type: 'text',
+*   content_length: 350,
+* });
+* ```
+*/
+const CONTENT_COPIED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONTENT_COPIED,
+	category: "user-interactions",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track content download
+*
+* @example
+* ```typescript
+* ai.CONTENT_DOWNLOADED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   content_id: 'content_456',
+*   content_type: 'document',
+*   file_format: 'pdf',
+*   file_size_bytes: 1024000,
+* });
+* ```
+*/
+const CONTENT_DOWNLOADED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONTENT_DOWNLOADED,
+	category: "user-interactions",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track content sharing
+*
+* @example
+* ```typescript
+* ai.CONTENT_SHARED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   content_id: 'content_456',
+*   content_type: 'code',
+*   share_platform: 'twitter',
+* });
+* ```
+*/
+const CONTENT_SHARED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONTENT_SHARED,
+	category: "user-interactions",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track AI suggestion acceptance
+*
+* @example
+* ```typescript
+* ai.SUGGESTION_ACCEPTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   suggestion_type: 'code-completion',
+*   suggestion_id: 'sug_123',
+* });
+* ```
+*/
+const SUGGESTION_ACCEPTED = createAITracker((properties) => ({
+	name: AI_EVENTS.SUGGESTION_ACCEPTED,
+	category: "user-interactions",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track AI suggestion rejection
+*
+* @example
+* ```typescript
+* ai.SUGGESTION_REJECTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   suggestion_type: 'text-completion',
+*   suggestion_id: 'sug_124',
+*   rejection_reason: 'not-relevant',
+* });
+* ```
+*/
+const SUGGESTION_REJECTED = createAITracker((properties) => ({
+	name: AI_EVENTS.SUGGESTION_REJECTED,
+	category: "user-interactions",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track inline edit applied to AI content
+*
+* @example
+* ```typescript
+* ai.INLINE_EDIT_APPLIED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   content_id: 'content_456',
+*   edit_type: 'user-refinement',
+*   characters_changed: 25,
+* });
+* ```
+*/
+const INLINE_EDIT_APPLIED = createAITracker((properties) => ({
+	name: AI_EVENTS.INLINE_EDIT_APPLIED,
+	category: "user-interactions",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track diff/changes viewed
+*
+* @example
+* ```typescript
+* ai.DIFF_VIEWED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   content_id: 'content_456',
+*   diff_type: 'side-by-side',
+*   lines_added: 15,
+*   lines_removed: 8,
+* });
+* ```
+*/
+const DIFF_VIEWED = createAITracker((properties) => ({
+	name: AI_EVENTS.DIFF_VIEWED,
+	category: "user-interactions",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track file upload
+*
+* @example
+* ```typescript
+* ai.FILE_UPLOADED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   file_type: 'pdf',
+*   file_size_bytes: 1024000,
+*   file_count: 1,
+* });
+* ```
+*/
+const FILE_UPLOADED = createAITracker((properties) => ({
+	name: AI_EVENTS.FILE_UPLOADED,
+	category: "files",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track file processing completion
+*
+* @example
+* ```typescript
+* ai.FILE_PROCESSED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   file_id: 'file_123',
+*   file_type: 'pdf',
+*   processing_time_ms: 2500,
+*   extracted_text_length: 5000,
+*   processing_status: 'success',
+* });
+* ```
+*/
+const FILE_PROCESSED = createAITracker((properties) => ({
+	name: AI_EVENTS.FILE_PROCESSED,
+	category: "files",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track file processing failure
+*
+* @example
+* ```typescript
+* ai.FILE_PROCESSING_FAILED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   file_id: 'file_124',
+*   file_type: 'docx',
+*   processing_status: 'failed',
+*   error_reason: 'unsupported-format',
+* });
+* ```
+*/
+const FILE_PROCESSING_FAILED = createAITracker((properties) => ({
+	name: AI_EVENTS.FILE_PROCESSING_FAILED,
+	category: "files",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track file download
+*
+* @example
+* ```typescript
+* ai.FILE_DOWNLOADED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   file_id: 'file_125',
+*   file_type: 'csv',
+*   file_size_bytes: 512000,
+* });
+* ```
+*/
+const FILE_DOWNLOADED = createAITracker((properties) => ({
+	name: AI_EVENTS.FILE_DOWNLOADED,
+	category: "files",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track file reference in conversation
+*
+* @example
+* ```typescript
+* ai.FILE_REFERENCED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   file_id: 'file_123',
+*   file_type: 'pdf',
+*   reference_context: 'answer-question',
+* });
+* ```
+*/
+const FILE_REFERENCED = createAITracker((properties) => ({
+	name: AI_EVENTS.FILE_REFERENCED,
+	category: "files",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track file deletion
+*
+* @example
+* ```typescript
+* ai.FILE_DELETED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   file_id: 'file_126',
+*   file_type: 'image',
+*   deleted_by: 'user',
+* });
+* ```
+*/
+const FILE_DELETED = createAITracker((properties) => ({
+	name: AI_EVENTS.FILE_DELETED,
+	category: "files",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track batch file processing
+*
+* @example
+* ```typescript
+* ai.BATCH_FILES_PROCESSED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   file_count: 5,
+*   total_size_bytes: 5120000,
+*   processing_time_ms: 8500,
+*   processing_status: 'success',
+* });
+* ```
+*/
+const BATCH_FILES_PROCESSED = createAITracker((properties) => ({
+	name: AI_EVENTS.BATCH_FILES_PROCESSED,
+	category: "files",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track context window update
+*
+* @example
+* ```typescript
+* ai.CONTEXT_WINDOW_UPDATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   context_size_tokens: 8000,
+*   context_type: 'conversation',
+* });
+* ```
+*/
+const CONTEXT_WINDOW_UPDATED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONTEXT_WINDOW_UPDATED,
+	category: "context",
+	properties,
+	requiredProperties: ["context_type"]
+}));
+/**
+* Track memory creation
+*
+* @example
+* ```typescript
+* ai.MEMORY_CREATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   memory_id: 'mem_123',
+*   memory_type: 'user-preference',
+*   memory_content_length: 50,
+*   memory_source: 'explicit',
+* });
+* ```
+*/
+const MEMORY_CREATED = createAITracker((properties) => ({
+	name: AI_EVENTS.MEMORY_CREATED,
+	category: "context",
+	properties,
+	requiredProperties: ["memory_type"]
+}));
+/**
+* Track memory retrieval
+*
+* @example
+* ```typescript
+* ai.MEMORY_RETRIEVED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   memory_id: 'mem_123',
+*   memory_type: 'user-preference',
+*   retrieval_relevance_score: 0.95,
+* });
+* ```
+*/
+const MEMORY_RETRIEVED = createAITracker((properties) => ({
+	name: AI_EVENTS.MEMORY_RETRIEVED,
+	category: "context",
+	properties,
+	requiredProperties: ["memory_type"]
+}));
+/**
+* Track memory update
+*
+* @example
+* ```typescript
+* ai.MEMORY_UPDATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   memory_id: 'mem_123',
+*   memory_type: 'fact',
+*   update_reason: 'correction',
+* });
+* ```
+*/
+const MEMORY_UPDATED = createAITracker((properties) => ({
+	name: AI_EVENTS.MEMORY_UPDATED,
+	category: "context",
+	properties,
+	requiredProperties: ["memory_type"]
+}));
+/**
+* Track memory deletion
+*
+* @example
+* ```typescript
+* ai.MEMORY_DELETED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   memory_id: 'mem_124',
+*   memory_type: 'user-preference',
+*   deleted_by: 'user',
+* });
+* ```
+*/
+const MEMORY_DELETED = createAITracker((properties) => ({
+	name: AI_EVENTS.MEMORY_DELETED,
+	category: "context",
+	properties,
+	requiredProperties: ["memory_type"]
+}));
+/**
+* Track custom instructions update
+*
+* @example
+* ```typescript
+* ai.CUSTOM_INSTRUCTIONS_UPDATED({
+*   model_id: 'gpt-4',
+*   user_id: 'user_123',
+*   instructions_length: 200,
+*   has_preferences: true,
+*   has_constraints: true,
+* });
+* ```
+*/
+const CUSTOM_INSTRUCTIONS_UPDATED = createAITracker((properties) => ({
+	name: AI_EVENTS.CUSTOM_INSTRUCTIONS_UPDATED,
+	category: "context",
+	properties,
+	requiredProperties: ["context_type"]
+}));
+/**
+* Track project context loading
+*
+* @example
+* ```typescript
+* ai.PROJECT_CONTEXT_LOADED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   context_type: 'project',
+*   context_size_tokens: 5000,
+*   project_id: 'proj_456',
+* });
+* ```
+*/
+const PROJECT_CONTEXT_LOADED = createAITracker((properties) => ({
+	name: AI_EVENTS.PROJECT_CONTEXT_LOADED,
+	category: "context",
+	properties,
+	requiredProperties: ["context_type"]
+}));
+/**
+* Track RAG query execution
+*
+* @example
+* ```typescript
+* ai.RAG_QUERY_EXECUTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   query_text: 'Find documentation about React hooks',
+*   query_embedding_dimensions: 1536,
+*   chunks_retrieved: 5,
+*   retrieval_time_ms: 150,
+*   retrieval_status: 'success',
+* });
+* ```
+*/
+const RAG_QUERY_EXECUTED = createAITracker((properties) => ({
+	name: AI_EVENTS.RAG_QUERY_EXECUTED,
+	category: "context",
+	properties,
+	requiredProperties: ["context_type"]
+}));
+/**
+* Track embedding generation
+*
+* @example
+* ```typescript
+* ai.EMBEDDING_GENERATED({
+*   model_id: 'text-embedding-ada-002',
+*   text_length: 500,
+*   embedding_dimensions: 1536,
+*   generation_time_ms: 80,
+* });
+* ```
+*/
+const EMBEDDING_GENERATED = createAITracker((properties) => ({
+	name: AI_EVENTS.EMBEDDING_GENERATED,
+	category: "context",
+	properties,
+	requiredProperties: ["context_type"]
+}));
+/**
+* Track knowledge base query
+*
+* @example
+* ```typescript
+* ai.KNOWLEDGE_BASE_QUERIED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   query_text: 'What is our refund policy?',
+*   results_found: 3,
+*   query_time_ms: 120,
+* });
+* ```
+*/
+const KNOWLEDGE_BASE_QUERIED = createAITracker((properties) => ({
+	name: AI_EVENTS.KNOWLEDGE_BASE_QUERIED,
+	category: "context",
+	properties,
+	requiredProperties: ["context_type"]
+}));
+/**
+* Track conversation sharing
+*
+* @example
+* ```typescript
+* ai.CONVERSATION_SHARED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   share_type: 'public-link',
+*   share_permissions: 'view-only',
+*   message_count: 15,
+* });
+* ```
+*/
+const CONVERSATION_SHARED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONVERSATION_SHARED,
+	category: "collaboration",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track conversation forking
+*
+* @example
+* ```typescript
+* ai.CONVERSATION_FORKED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   original_conversation_id: 'conv_123',
+*   new_conversation_id: 'conv_125',
+*   forked_from_message_id: 'msg_460',
+* });
+* ```
+*/
+const CONVERSATION_FORKED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONVERSATION_FORKED,
+	category: "collaboration",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track workspace creation
+*
+* @example
+* ```typescript
+* ai.WORKSPACE_CREATED({
+*   workspace_id: 'ws_001',
+*   model_id: 'claude-3-5-sonnet',
+*   workspace_type: 'team',
+*   member_count: 5,
+* });
+* ```
+*/
+const WORKSPACE_CREATED = createAITracker((properties) => ({
+	name: AI_EVENTS.WORKSPACE_CREATED,
+	category: "collaboration",
+	properties,
+	requiredProperties: ["action"]
+}));
+/**
+* Track member invitation
+*
+* @example
+* ```typescript
+* ai.MEMBER_INVITED({
+*   workspace_id: 'ws_001',
+*   model_id: 'gpt-4',
+*   invitee_role: 'member',
+*   invitation_method: 'email',
+* });
+* ```
+*/
+const MEMBER_INVITED = createAITracker((properties) => ({
+	name: AI_EVENTS.MEMBER_INVITED,
+	category: "collaboration",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track collaboration comment
+*
+* @example
+* ```typescript
+* ai.COMMENT_ADDED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   comment_target: 'message',
+*   comment_length: 150,
+* });
+* ```
+*/
+const COMMENT_ADDED = createAITracker((properties) => ({
+	name: AI_EVENTS.COMMENT_ADDED,
+	category: "collaboration",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track permission change
+*
+* @example
+* ```typescript
+* ai.PERMISSION_CHANGED({
+*   workspace_id: 'ws_001',
+*   model_id: 'gpt-4',
+*   target_user_id: 'user_456',
+*   old_permission: 'viewer',
+*   new_permission: 'editor',
+* });
+* ```
+*/
+const PERMISSION_CHANGED = createAITracker((properties) => ({
+	name: AI_EVENTS.PERMISSION_CHANGED,
+	category: "collaboration",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track conversation rename
+*
+* @example
+* ```typescript
+* ai.CONVERSATION_RENAMED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   old_title: 'Chat',
+*   new_title: 'React Project Discussion',
+* });
+* ```
+*/
+const CONVERSATION_RENAMED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONVERSATION_RENAMED,
+	category: "workspace",
+	properties,
+	requiredProperties: ["action"]
+}));
+/**
+* Track conversation archival
+*
+* @example
+* ```typescript
+* ai.CONVERSATION_ARCHIVED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   archive_reason: 'completed',
+* });
+* ```
+*/
+const CONVERSATION_ARCHIVED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONVERSATION_ARCHIVED,
+	category: "workspace",
+	properties,
+	requiredProperties: ["action"]
+}));
+/**
+* Track conversation deletion
+*
+* @example
+* ```typescript
+* ai.CONVERSATION_DELETED({
+*   conversation_id: 'conv_124',
+*   model_id: 'claude-3-5-sonnet',
+*   message_count: 8,
+*   deleted_by: 'user',
+* });
+* ```
+*/
+const CONVERSATION_DELETED = createAITracker((properties) => ({
+	name: AI_EVENTS.CONVERSATION_DELETED,
+	category: "workspace",
+	properties,
+	requiredProperties: ["action"]
+}));
+/**
+* Track folder creation
+*
+* @example
+* ```typescript
+* ai.FOLDER_CREATED({
+*   workspace_id: 'ws_001',
+*   model_id: 'gpt-4',
+*   folder_name: 'Project Ideas',
+*   parent_folder_id: 'folder_root',
+* });
+* ```
+*/
+const FOLDER_CREATED = createAITracker((properties) => ({
+	name: AI_EVENTS.FOLDER_CREATED,
+	category: "workspace",
+	properties,
+	requiredProperties: ["action"]
+}));
+/**
+* Track tag addition
+*
+* @example
+* ```typescript
+* ai.TAG_ADDED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   tag_name: 'important',
+*   tag_category: 'priority',
+* });
+* ```
+*/
+const TAG_ADDED = createAITracker((properties) => ({
+	name: AI_EVENTS.TAG_ADDED,
+	category: "workspace",
+	properties,
+	requiredProperties: ["action"]
+}));
+/**
+* Track conversation search
+*
+* @example
+* ```typescript
+* ai.SEARCH_PERFORMED({
+*   model_id: 'gpt-4',
+*   search_query: 'React hooks',
+*   results_found: 12,
+*   search_scope: 'all-conversations',
+* });
+* ```
+*/
+const SEARCH_PERFORMED = createAITracker((properties) => ({
+	name: AI_EVENTS.SEARCH_PERFORMED,
+	category: "workspace",
+	properties,
+	requiredProperties: ["action"]
+}));
+/**
+* Track filter application
+*
+* @example
+* ```typescript
+* ai.FILTER_APPLIED({
+*   model_id: 'claude-3-5-sonnet',
+*   filter_type: 'date-range',
+*   filter_value: 'last-7-days',
+*   results_count: 24,
+* });
+* ```
+*/
+const FILTER_APPLIED = createAITracker((properties) => ({
+	name: AI_EVENTS.FILTER_APPLIED,
+	category: "workspace",
+	properties,
+	requiredProperties: ["action"]
+}));
+/**
+* Track user feedback
+*
+* @example
+* ```typescript
+* ai.FEEDBACK_PROVIDED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   message_id: 'msg_457',
+*   feedback_type: 'thumbs-up',
+*   feedback_comment_length: 50,
+* });
+* ```
+*/
+const FEEDBACK_PROVIDED = createAITracker((properties) => ({
+	name: AI_EVENTS.FEEDBACK_PROVIDED,
+	category: "feedback",
+	properties,
+	requiredProperties: ["feedback_type", "message_id"]
+}));
+/**
+* Track response rating
+*
+* @example
+* ```typescript
+* ai.RESPONSE_RATED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   message_id: 'msg_458',
+*   rating_value: 5,
+*   rating_scale: '1-5',
+* });
+* ```
+*/
+const RESPONSE_RATED = createAITracker((properties) => ({
+	name: AI_EVENTS.RESPONSE_RATED,
+	category: "feedback",
+	properties,
+	requiredProperties: ["feedback_type", "message_id"]
+}));
+/**
+* Track bug report
+*
+* @example
+* ```typescript
+* ai.BUG_REPORTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   bug_type: 'incorrect-output',
+*   bug_severity: 'medium',
+* });
+* ```
+*/
+const BUG_REPORTED = createAITracker((properties) => ({
+	name: AI_EVENTS.BUG_REPORTED,
+	category: "feedback",
+	properties,
+	requiredProperties: ["feedback_type", "message_id"]
+}));
+/**
+* Track feature request
+*
+* @example
+* ```typescript
+* ai.FEATURE_REQUESTED({
+*   model_id: 'claude-3-5-sonnet',
+*   feature_category: 'ui',
+*   feature_description_length: 200,
+* });
+* ```
+*/
+const FEATURE_REQUESTED = createAITracker((properties) => ({
+	name: AI_EVENTS.FEATURE_REQUESTED,
+	category: "feedback",
+	properties,
+	requiredProperties: ["feedback_type", "message_id"]
+}));
+/**
+* Track harmful content flag
+*
+* @example
+* ```typescript
+* ai.HARMFUL_CONTENT_FLAGGED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   message_id: 'msg_459',
+*   content_type: 'misinformation',
+*   severity: 'high',
+* });
+* ```
+*/
+const HARMFUL_CONTENT_FLAGGED = createAITracker((properties) => ({
+	name: AI_EVENTS.HARMFUL_CONTENT_FLAGGED,
+	category: "feedback",
+	properties,
+	requiredProperties: ["feedback_type", "message_id"]
+}));
+/**
+* Track quality issue report
+*
+* @example
+* ```typescript
+* ai.QUALITY_ISSUE_REPORTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   message_id: 'msg_460',
+*   issue_type: 'factual-error',
+*   issue_severity: 'medium',
+* });
+* ```
+*/
+const QUALITY_ISSUE_REPORTED = createAITracker((properties) => ({
+	name: AI_EVENTS.QUALITY_ISSUE_REPORTED,
+	category: "feedback",
+	properties,
+	requiredProperties: ["feedback_type", "message_id"]
+}));
+/**
+* Track model switch
+*
+* @example
+* ```typescript
+* ai.MODEL_SWITCHED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   previous_model: 'gpt-3.5-turbo',
+*   switch_reason: 'user-preference',
+* });
+* ```
+*/
+const MODEL_SWITCHED = createAITracker((properties) => ({
+	name: AI_EVENTS.MODEL_SWITCHED,
+	category: "system",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track settings update
+*
+* @example
+* ```typescript
+* ai.SETTINGS_UPDATED({
+*   model_id: 'claude-3-5-sonnet',
+*   user_id: 'user_123',
+*   settings_category: 'appearance',
+*   settings_changed: ['theme', 'font-size'],
+* });
+* ```
+*/
+const SETTINGS_UPDATED = createAITracker((properties) => ({
+	name: AI_EVENTS.SETTINGS_UPDATED,
+	category: "system",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track error occurrence
+*
+* @example
+* ```typescript
+* ai.ERROR_OCCURRED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   error_type: 'api-error',
+*   error_code: '500',
+*   error_message: 'Internal server error',
+* });
+* ```
+*/
+const ERROR_OCCURRED = createAITracker((properties) => ({
+	name: AI_EVENTS.ERROR_OCCURRED,
+	category: "system",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track rate limit hit
+*
+* @example
+* ```typescript
+* ai.RATE_LIMIT_HIT({
+*   model_id: 'claude-3-5-sonnet',
+*   user_id: 'user_123',
+*   limit_type: 'requests-per-minute',
+*   retry_after_seconds: 60,
+* });
+* ```
+*/
+const RATE_LIMIT_HIT = createAITracker((properties) => ({
+	name: AI_EVENTS.RATE_LIMIT_HIT,
+	category: "system",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track token usage
+*
+* @example
+* ```typescript
+* ai.TOKEN_USAGE_TRACKED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   input_tokens: 1500,
+*   output_tokens: 800,
+*   total_tokens: 2300,
+*   cost: 0.0345,
+*   cost_currency: 'USD',
+* });
+* ```
+*/
+const TOKEN_USAGE_TRACKED = createAITracker((properties) => ({
+	name: AI_EVENTS.TOKEN_USAGE_TRACKED,
+	category: "system",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track performance measurement
+*
+* @example
+* ```typescript
+* ai.PERFORMANCE_MEASURED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   operation_type: 'message-generation',
+*   duration_ms: 850,
+*   performance_tier: 'normal',
+* });
+* ```
+*/
+const PERFORMANCE_MEASURED = createAITracker((properties) => ({
+	name: AI_EVENTS.PERFORMANCE_MEASURED,
+	category: "system",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track tool call start
+*
+* @example
+* ```typescript
+* ai.TOOL_CALL_STARTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   tool_name: 'web_search',
+*   tool_type: 'built-in',
+* });
+* ```
+*/
+const TOOL_CALL_STARTED = createAITracker((properties) => ({
+	name: AI_EVENTS.TOOL_CALL_STARTED,
+	category: "tool",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track tool call completion
+*
+* @example
+* ```typescript
+* ai.TOOL_CALL_COMPLETED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   tool_name: 'calculator',
+*   tool_type: 'custom',
+*   result_status: 'success',
+*   execution_time_ms: 50,
+* });
+* ```
+*/
+const TOOL_CALL_COMPLETED = createAITracker((properties) => ({
+	name: AI_EVENTS.TOOL_CALL_COMPLETED,
+	category: "tool",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track tool call failure
+*
+* @example
+* ```typescript
+* ai.TOOL_CALL_FAILED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   tool_name: 'api_caller',
+*   tool_type: 'custom',
+*   error_message: 'Connection timeout',
+*   execution_time_ms: 5000,
+* });
+* ```
+*/
+const TOOL_CALL_FAILED = createAITracker((properties) => ({
+	name: AI_EVENTS.TOOL_CALL_FAILED,
+	category: "tool",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track function execution
+*
+* @example
+* ```typescript
+* ai.FUNCTION_EXECUTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   function_name: 'getData',
+*   execution_status: 'success',
+*   execution_time_ms: 120,
+* });
+* ```
+*/
+const FUNCTION_EXECUTED = createAITracker((properties) => ({
+	name: AI_EVENTS.FUNCTION_EXECUTED,
+	category: "tool",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track API request
+*
+* @example
+* ```typescript
+* ai.API_REQUEST_MADE({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   api_endpoint: '/v1/data',
+*   api_method: 'GET',
+*   response_status: 200,
+*   response_time_ms: 250,
+* });
+* ```
+*/
+const API_REQUEST_MADE = createAITracker((properties) => ({
+	name: AI_EVENTS.API_REQUEST_MADE,
+	category: "tool",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track plugin activation
+*
+* @example
+* ```typescript
+* ai.PLUGIN_ACTIVATED({
+*   model_id: 'claude-3-5-sonnet',
+*   plugin_name: 'web-browser',
+*   plugin_version: '1.2.0',
+* });
+* ```
+*/
+const PLUGIN_ACTIVATED = createAITracker((properties) => ({
+	name: AI_EVENTS.PLUGIN_ACTIVATED,
+	category: "tool",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track extension usage
+*
+* @example
+* ```typescript
+* ai.EXTENSION_USED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   extension_name: 'code-runner',
+*   extension_action: 'execute',
+* });
+* ```
+*/
+const EXTENSION_USED = createAITracker((properties) => ({
+	name: AI_EVENTS.EXTENSION_USED,
+	category: "tool",
+	properties,
+	requiredProperties: []
+}));
+/**
+* Track web search
+*
+* @example
+* ```typescript
+* ai.WEB_SEARCH_PERFORMED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   search_query: 'latest React 19 features',
+*   search_engine: 'google',
+*   results_count: 10,
+*   search_time_ms: 450,
+* });
+* ```
+*/
+const WEB_SEARCH_PERFORMED = createAITracker((properties) => ({
+	name: AI_EVENTS.WEB_SEARCH_PERFORMED,
+	category: "context",
+	properties,
+	requiredProperties: ["query", "search_scope"]
+}));
+/**
+* Track citation addition
+*
+* @example
+* ```typescript
+* ai.CITATION_ADDED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   message_id: 'msg_461',
+*   citation_source: 'https://react.dev',
+*   citation_type: 'web',
+* });
+* ```
+*/
+const CITATION_ADDED = createAITracker((properties) => ({
+	name: AI_EVENTS.CITATION_ADDED,
+	category: "context",
+	properties,
+	requiredProperties: ["query", "search_scope"]
+}));
+/**
+* Track browse session start
+*
+* @example
+* ```typescript
+* ai.BROWSE_SESSION_STARTED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   browse_target_url: 'https://example.com',
+* });
+* ```
+*/
+const BROWSE_SESSION_STARTED = createAITracker((properties) => ({
+	name: AI_EVENTS.BROWSE_SESSION_STARTED,
+	category: "context",
+	properties,
+	requiredProperties: ["query", "search_scope"]
+}));
+/**
+* Track page content fetch
+*
+* @example
+* ```typescript
+* ai.PAGE_CONTENT_FETCHED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   page_url: 'https://example.com/article',
+*   content_length: 5000,
+*   fetch_time_ms: 800,
+* });
+* ```
+*/
+const PAGE_CONTENT_FETCHED = createAITracker((properties) => ({
+	name: AI_EVENTS.PAGE_CONTENT_FETCHED,
+	category: "context",
+	properties,
+	requiredProperties: ["query", "search_scope"]
+}));
+/**
+* Track search results ranking
+*
+* @example
+* ```typescript
+* ai.SEARCH_RESULTS_RANKED({
+*   conversation_id: 'conv_123',
+*   model_id: 'gpt-4',
+*   results_count: 20,
+*   ranking_algorithm: 'relevance',
+* });
+* ```
+*/
+const SEARCH_RESULTS_RANKED = createAITracker((properties) => ({
+	name: AI_EVENTS.SEARCH_RESULTS_RANKED,
+	category: "context",
+	properties,
+	requiredProperties: ["query", "search_scope"]
+}));
+/**
+* Track external source access
+*
+* @example
+* ```typescript
+* ai.EXTERNAL_SOURCE_ACCESSED({
+*   conversation_id: 'conv_123',
+*   model_id: 'claude-3-5-sonnet',
+*   source_type: 'api',
+*   source_url: 'https://api.example.com/data',
+*   access_time_ms: 350,
+* });
+* ```
+*/
+const EXTERNAL_SOURCE_ACCESSED = createAITracker((properties) => ({
+	name: AI_EVENTS.EXTERNAL_SOURCE_ACCESSED,
+	category: "context",
+	properties,
+	requiredProperties: ["query", "search_scope"]
+}));
+
+//#endregion
+//#region src/shared/emitters/ai/events/agent.ts
+/**
+* @fileoverview Agent-related AI SDK v6 events
+* Agent-related AI SDK v6 events
+*/
+/**
+* Track when an AI agent is created
+*/
+function agentCreated(properties, options) {
+	validateRequiredProperties(properties, ["model_id"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		agent_type: properties.agent_type,
+		system_prompt_length: properties.system_prompt_length,
+		tools_available: properties.tools_available,
+		tools_count: properties.tools_count
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.AGENT_CREATED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id"]
+	}, options);
+}
+/**
+* Track when an AI agent execution starts
+*/
+function agentExecutionStarted(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "agent_id"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		agent_type: properties.agent_type
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.AGENT_EXECUTION_STARTED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "agent_id"]
+	}, options);
+}
+/**
+* Track when an AI agent execution completes successfully
+*/
+function agentExecutionCompleted(properties, options) {
+	validateRequiredProperties(properties, [
+		"model_id",
+		"agent_id",
+		"status"
+	]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		...normalizeTokenUsage(properties),
+		completion_type: properties.completion_type,
+		status: properties.status,
+		total_duration_ms: properties.total_duration_ms,
+		step_count: properties.step_count,
+		finish_reason: properties.finish_reason,
+		has_tools: properties.has_tools
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.AGENT_EXECUTION_COMPLETED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: [
+			"model_id",
+			"agent_id",
+			"status"
+		]
+	}, options);
+}
+/**
+* Track when an AI agent execution fails
+*/
+function agentExecutionFailed(properties, options) {
+	validateRequiredProperties(properties, [
+		"model_id",
+		"agent_id",
+		"error_message"
+	]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		...normalizeTokenUsage(properties),
+		completion_type: properties.completion_type,
+		status: "failed",
+		error_message: properties.error_message,
+		retry_count: properties.retry_count,
+		total_duration_ms: properties.total_duration_ms
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.AGENT_EXECUTION_FAILED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: [
+			"model_id",
+			"agent_id",
+			"error_message"
+		]
+	}, options);
+}
+
+//#endregion
+//#region src/shared/emitters/ai/events/chat.ts
+/**
+* @fileoverview Chat-related AI SDK v6 events
+* Chat-related AI SDK v6 events
+*/
+/**
+* Track when a chat session starts
+*/
+function chatSessionStarted(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "session_id"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		session_type: properties.session_type
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.CHAT_SESSION_STARTED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "session_id"]
+	}, options);
+}
+/**
+* Track when a chat session ends
+*/
+function chatSessionEnded(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "session_id"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		duration_ms: properties.duration_ms,
+		message_count: properties.message_count,
+		tool_calls_count: properties.tool_calls_count,
+		total_tokens: properties.total_tokens,
+		session_end_reason: properties.session_end_reason
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.CHAT_SESSION_ENDED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "session_id"]
+	}, options);
+}
+/**
+* Track when a user sends a chat message
+*/
+function chatMessageSent(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "message_role"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		message_id: properties.message_id,
+		message_role: properties.message_role,
+		message_length: properties.message_length,
+		message_index: properties.message_index,
+		has_images: properties.has_images,
+		parent_message_id: properties.parent_message_id
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.CHAT_MESSAGE_SENT,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "message_role"]
+	}, options);
+}
+/**
+* Track when the assistant's chat message is received
+*/
+function chatMessageReceived(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "message_role"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		message_id: properties.message_id,
+		message_role: properties.message_role,
+		message_length: properties.message_length,
+		message_index: properties.message_index,
+		finish_reason: properties.finish_reason,
+		response_time_ms: properties.response_time_ms,
+		is_streaming: properties.is_streaming
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.CHAT_MESSAGE_RECEIVED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "message_role"]
+	}, options);
+}
+
+//#endregion
+//#region src/shared/emitters/ai/events/chatbot-ecommerce.ts
+/**
+* @fileoverview E-commerce chatbot-specific AI SDK v6 events
+* E-commerce chatbot-specific AI SDK v6 events
+*/
+/**
+* Maximum number of product IDs to include in chatbot ecommerce events.
+* Limits payload size and prevents excessive data in analytics.
+*/
+const MAX_PRODUCT_IDS = 20;
+/**
+* Track when chatbot detects user intent
+*/
+function chatbotIntentDetected(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "message"]);
+	const intent = properties.intent_detected ?? detectChatbotIntent(properties.message);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		intent_detected: intent
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.CHATBOT_INTENT_DETECTED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id"]
+	}, options);
+}
+/**
+* Track when chatbot assists with cart operations
+*/
+function chatbotCartAssisted(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "cart_id"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		cart_id: properties.cart_id,
+		cart_value: properties.cart_value,
+		product_count: properties.product_count,
+		product_ids: properties.product_ids ? truncateArray(properties.product_ids, MAX_PRODUCT_IDS) : void 0,
+		intent_detected: properties.intent_detected
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.CHATBOT_CART_ASSISTED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "cart_id"]
+	}, options);
+}
+/**
+* Track when chatbot assists with order-related queries
+*/
+function chatbotOrderAssisted(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "order_id"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		order_id: properties.order_id,
+		intent_detected: properties.intent_detected
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.CHATBOT_ORDER_ASSISTED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "order_id"]
+	}, options);
+}
+/**
+* Track when chatbot shows product recommendations
+*/
+function chatbotProductRecommended(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "product_ids"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		product_count: properties.product_count ?? properties.product_ids?.length,
+		product_ids: properties.product_ids ? truncateArray(properties.product_ids, MAX_PRODUCT_IDS) : void 0,
+		recommendation_shown: true,
+		intent_detected: properties.intent_detected
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.CHATBOT_PRODUCT_RECOMMENDED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "product_ids"]
+	}, options);
+}
+
+//#endregion
+//#region src/shared/emitters/ai/events/completion.ts
+/**
+* @fileoverview Completion-related AI SDK v6 events
+* Completion-related AI SDK v6 events
+*/
+/**
+* Track when a completion is requested
+*/
+function completionRequested(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "completion_type"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		...normalizeModelConfig(properties),
+		completion_type: properties.completion_type,
+		prompt_length: properties.prompt_length,
+		has_tools: properties.has_tools
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.COMPLETION_REQUESTED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "completion_type"]
+	}, options);
+}
+/**
+* Track when a completion is successfully generated
+*/
+function completionGenerated(properties, options) {
+	validateRequiredProperties(properties, [
+		"model_id",
+		"completion_type",
+		"status"
+	]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		...normalizeTokenUsage(properties),
+		...normalizeModelConfig(properties),
+		completion_type: properties.completion_type,
+		status: properties.status,
+		finish_reason: properties.finish_reason,
+		total_duration_ms: properties.total_duration_ms,
+		step_count: properties.step_count,
+		retry_count: properties.retry_count
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.COMPLETION_GENERATED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: [
+			"model_id",
+			"completion_type",
+			"status"
+		]
+	}, options);
+}
+/**
+* Track when a completion fails
+*/
+function completionFailed(properties, options) {
+	validateRequiredProperties(properties, [
+		"model_id",
+		"completion_type",
+		"error_message"
+	]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		...normalizeTokenUsage(properties),
+		completion_type: properties.completion_type,
+		status: "failed",
+		error_message: properties.error_message,
+		retry_count: properties.retry_count,
+		total_duration_ms: properties.total_duration_ms
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.COMPLETION_FAILED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: [
+			"model_id",
+			"completion_type",
+			"error_message"
+		]
+	}, options);
+}
+
+//#endregion
+//#region src/shared/emitters/ai/events/streaming.ts
+/**
+* @fileoverview Streaming-related AI SDK v6 events
+* Streaming-related AI SDK v6 events
+*/
+/**
+* Track when streaming starts
+*/
+function streamStarted(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "stream_type"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		stream_type: properties.stream_type
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.STREAM_STARTED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "stream_type"]
+	}, options);
+}
+/**
+* Track when a stream chunk is received
+*/
+function streamChunkReceived(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "stream_type"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		stream_type: properties.stream_type,
+		chunk_index: properties.chunk_index
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.STREAM_CHUNK_RECEIVED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "stream_type"]
+	}, options);
+}
+/**
+* Track when streaming completes
+*/
+function streamCompleted(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "stream_type"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		stream_type: properties.stream_type,
+		chunk_count: properties.chunk_count,
+		stream_duration_ms: properties.stream_duration_ms,
+		time_to_first_chunk_ms: properties.time_to_first_chunk_ms,
+		chunks_per_second: properties.chunks_per_second
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.STREAM_COMPLETED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "stream_type"]
+	}, options);
+}
+/**
+* Track when streaming fails
+*/
+function streamFailed(properties, options) {
+	validateRequiredProperties(properties, [
+		"model_id",
+		"stream_type",
+		"error_message"
+	]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		stream_type: properties.stream_type,
+		error_message: properties.error_message,
+		chunk_count: properties.chunk_count,
+		stream_duration_ms: properties.stream_duration_ms
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.STREAM_FAILED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: [
+			"model_id",
+			"stream_type",
+			"error_message"
+		]
+	}, options);
+}
+
+//#endregion
+//#region src/shared/emitters/ai/events/tool.ts
+/**
+* @fileoverview Tool-related AI SDK v6 events
+* Tool-related AI SDK v6 events
+*/
+/**
+* Track when a tool call starts
+*/
+function toolCallStarted(properties, options) {
+	validateRequiredProperties(properties, ["model_id", "tool_name"]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		tool_name: properties.tool_name,
+		tool_type: properties.tool_type,
+		input_size: properties.input_size
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.TOOL_CALL_STARTED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: ["model_id", "tool_name"]
+	}, options);
+}
+/**
+* Track when a tool call completes successfully
+*/
+function toolCallCompleted(properties, options) {
+	validateRequiredProperties(properties, [
+		"model_id",
+		"tool_name",
+		"result_status"
+	]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		tool_name: properties.tool_name,
+		tool_type: properties.tool_type,
+		result_status: properties.result_status,
+		execution_time_ms: properties.execution_time_ms,
+		input_size: properties.input_size,
+		output_size: properties.output_size
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.TOOL_CALL_COMPLETED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: [
+			"model_id",
+			"tool_name",
+			"result_status"
+		]
+	}, options);
+}
+/**
+* Track when a tool call fails
+*/
+function toolCallFailed(properties, options) {
+	validateRequiredProperties(properties, [
+		"model_id",
+		"tool_name",
+		"error_message"
+	]);
+	const normalizedProps = {
+		...normalizeBaseProperties(properties),
+		tool_name: properties.tool_name,
+		tool_type: properties.tool_type,
+		result_status: "error",
+		error_message: properties.error_message,
+		execution_time_ms: properties.execution_time_ms
+	};
+	return trackAISDK({
+		name: AI_SDK_EVENTS.TOOL_CALL_FAILED,
+		category: "ai-sdk",
+		properties: cleanProperties(normalizedProps),
+		requiredProperties: [
+			"model_id",
+			"tool_name",
+			"error_message"
+		]
+	}, options);
+}
+
+//#endregion
+//#region src/shared/emitters/ai/index.ts
+var ai_exports = /* @__PURE__ */ __exportAll({
+	AI_EVENTS: () => AI_EVENTS,
+	AI_SDK_EVENTS: () => AI_SDK_EVENTS,
+	API_REQUEST_MADE: () => API_REQUEST_MADE,
+	ARTIFACT_CREATED: () => ARTIFACT_CREATED,
+	ARTIFACT_EDITED: () => ARTIFACT_EDITED,
+	ARTIFACT_EXECUTED: () => ARTIFACT_EXECUTED,
+	ARTIFACT_FORKED: () => ARTIFACT_FORKED,
+	ARTIFACT_PUBLISHED: () => ARTIFACT_PUBLISHED,
+	BATCH_FILES_PROCESSED: () => BATCH_FILES_PROCESSED,
+	BRANCH_CREATED: () => BRANCH_CREATED,
+	BRANCH_MERGED: () => BRANCH_MERGED,
+	BROWSE_SESSION_STARTED: () => BROWSE_SESSION_STARTED,
+	BUG_REPORTED: () => BUG_REPORTED,
+	CANVAS_OPENED: () => CANVAS_OPENED,
+	CITATION_ADDED: () => CITATION_ADDED,
+	CODE_COPIED: () => CODE_COPIED,
+	CODE_DEBUGGED: () => CODE_DEBUGGED,
+	CODE_EXECUTED: () => CODE_EXECUTED,
+	CODE_EXPLAINED: () => CODE_EXPLAINED,
+	CODE_GENERATED: () => CODE_GENERATED,
+	CODE_REFACTORED: () => CODE_REFACTORED,
+	CODE_TRANSLATED: () => CODE_TRANSLATED,
+	COMMENT_ADDED: () => COMMENT_ADDED,
+	COMPLETION_GENERATED: () => COMPLETION_GENERATED,
+	CONTENT_COPIED: () => CONTENT_COPIED,
+	CONTENT_DOWNLOADED: () => CONTENT_DOWNLOADED,
+	CONTENT_SHARED: () => CONTENT_SHARED,
+	CONTEXT_WINDOW_UPDATED: () => CONTEXT_WINDOW_UPDATED,
+	CONVERSATION_ARCHIVED: () => CONVERSATION_ARCHIVED,
+	CONVERSATION_DELETED: () => CONVERSATION_DELETED,
+	CONVERSATION_ENDED: () => CONVERSATION_ENDED,
+	CONVERSATION_FORKED: () => CONVERSATION_FORKED,
+	CONVERSATION_RENAMED: () => CONVERSATION_RENAMED,
+	CONVERSATION_RESUMED: () => CONVERSATION_RESUMED,
+	CONVERSATION_SHARED: () => CONVERSATION_SHARED,
+	CONVERSATION_STARTED: () => CONVERSATION_STARTED,
+	CUSTOM_INSTRUCTIONS_UPDATED: () => CUSTOM_INSTRUCTIONS_UPDATED,
+	DIFF_VIEWED: () => DIFF_VIEWED,
+	DOCUMENT_CREATED: () => DOCUMENT_CREATED,
+	EMAIL_DRAFTED: () => EMAIL_DRAFTED,
+	EMBEDDING_GENERATED: () => EMBEDDING_GENERATED,
+	ERROR_OCCURRED: () => ERROR_OCCURRED,
+	EXTENSION_USED: () => EXTENSION_USED,
+	EXTERNAL_SOURCE_ACCESSED: () => EXTERNAL_SOURCE_ACCESSED,
+	FEATURE_REQUESTED: () => FEATURE_REQUESTED,
+	FEEDBACK_PROVIDED: () => FEEDBACK_PROVIDED,
+	FILE_DELETED: () => FILE_DELETED,
+	FILE_DOWNLOADED: () => FILE_DOWNLOADED,
+	FILE_PROCESSED: () => FILE_PROCESSED,
+	FILE_PROCESSING_FAILED: () => FILE_PROCESSING_FAILED,
+	FILE_REFERENCED: () => FILE_REFERENCED,
+	FILE_UPLOADED: () => FILE_UPLOADED,
+	FILTER_APPLIED: () => FILTER_APPLIED,
+	FOLDER_CREATED: () => FOLDER_CREATED,
+	FUNCTION_EXECUTED: () => FUNCTION_EXECUTED,
+	HARMFUL_CONTENT_FLAGGED: () => HARMFUL_CONTENT_FLAGGED,
+	IMAGE_EDITED: () => IMAGE_EDITED,
+	IMAGE_GENERATED: () => IMAGE_GENERATED,
+	INLINE_EDIT_APPLIED: () => INLINE_EDIT_APPLIED,
+	KNOWLEDGE_BASE_QUERIED: () => KNOWLEDGE_BASE_QUERIED,
+	LIVE_PREVIEW_TOGGLED: () => LIVE_PREVIEW_TOGGLED,
+	MAX_PRODUCT_IDS: () => MAX_PRODUCT_IDS,
+	MEMBER_INVITED: () => MEMBER_INVITED,
+	MEMORY_CREATED: () => MEMORY_CREATED,
+	MEMORY_DELETED: () => MEMORY_DELETED,
+	MEMORY_RETRIEVED: () => MEMORY_RETRIEVED,
+	MEMORY_UPDATED: () => MEMORY_UPDATED,
+	MESSAGE_DELETED: () => MESSAGE_DELETED,
+	MESSAGE_EDITED: () => MESSAGE_EDITED,
+	MESSAGE_RECEIVED: () => MESSAGE_RECEIVED,
+	MESSAGE_REGENERATED: () => MESSAGE_REGENERATED,
+	MESSAGE_SENT: () => MESSAGE_SENT,
+	MODEL_SWITCHED: () => MODEL_SWITCHED,
+	OUTLINE_CREATED: () => OUTLINE_CREATED,
+	PAGE_CONTENT_FETCHED: () => PAGE_CONTENT_FETCHED,
+	PERFORMANCE_MEASURED: () => PERFORMANCE_MEASURED,
+	PERMISSION_CHANGED: () => PERMISSION_CHANGED,
+	PLUGIN_ACTIVATED: () => PLUGIN_ACTIVATED,
+	PROJECT_CONTEXT_LOADED: () => PROJECT_CONTEXT_LOADED,
+	QUALITY_ISSUE_REPORTED: () => QUALITY_ISSUE_REPORTED,
+	RAG_QUERY_EXECUTED: () => RAG_QUERY_EXECUTED,
+	RATE_LIMIT_HIT: () => RATE_LIMIT_HIT,
+	RESPONSE_RATED: () => RESPONSE_RATED,
+	REWRITE_GENERATED: () => REWRITE_GENERATED,
+	SEARCH_PERFORMED: () => SEARCH_PERFORMED,
+	SEARCH_RESULTS_RANKED: () => SEARCH_RESULTS_RANKED,
+	SETTINGS_UPDATED: () => SETTINGS_UPDATED,
+	STOP_GENERATION: () => STOP_GENERATION,
+	STREAMING_CHUNK_RECEIVED: () => STREAMING_CHUNK_RECEIVED,
+	STREAMING_COMPLETED: () => STREAMING_COMPLETED,
+	STREAMING_STARTED: () => STREAMING_STARTED,
+	SUGGESTION_ACCEPTED: () => SUGGESTION_ACCEPTED,
+	SUGGESTION_REJECTED: () => SUGGESTION_REJECTED,
+	SUMMARY_GENERATED: () => SUMMARY_GENERATED,
+	TAG_ADDED: () => TAG_ADDED,
+	TEXT_GENERATED: () => TEXT_GENERATED,
+	TOKEN_USAGE_TRACKED: () => TOKEN_USAGE_TRACKED,
+	TOOL_CALL_COMPLETED: () => TOOL_CALL_COMPLETED,
+	TOOL_CALL_FAILED: () => TOOL_CALL_FAILED,
+	TOOL_CALL_STARTED: () => TOOL_CALL_STARTED,
+	TRANSLATION_GENERATED: () => TRANSLATION_GENERATED,
+	WEB_SEARCH_PERFORMED: () => WEB_SEARCH_PERFORMED,
+	WORKSPACE_CREATED: () => WORKSPACE_CREATED,
+	agentCreated: () => agentCreated,
+	agentExecutionCompleted: () => agentExecutionCompleted,
+	agentExecutionFailed: () => agentExecutionFailed,
+	agentExecutionStarted: () => agentExecutionStarted,
+	calculateCompletionMetrics: () => calculateCompletionMetrics,
+	calculateCost: () => calculateCost,
+	calculateQualityScore: () => calculateQualityScore,
+	chatMessageReceived: () => chatMessageReceived,
+	chatMessageSent: () => chatMessageSent,
+	chatSessionEnded: () => chatSessionEnded,
+	chatSessionStarted: () => chatSessionStarted,
+	chatbotCartAssisted: () => chatbotCartAssisted,
+	chatbotIntentDetected: () => chatbotIntentDetected,
+	chatbotOrderAssisted: () => chatbotOrderAssisted,
+	chatbotProductRecommended: () => chatbotProductRecommended,
+	cleanProperties: () => cleanProperties,
+	completionFailed: () => completionFailed,
+	completionGenerated: () => completionGenerated,
+	completionRequested: () => completionRequested,
+	createAISDKTracker: () => createAISDKTracker,
+	createAITracker: () => createAITracker,
+	detectChatbotIntent: () => detectChatbotIntent,
+	detectIntent: () => detectIntent,
+	detectSentiment: () => detectSentiment,
+	extractModelProvider: () => extractModelProvider,
+	extractProductMentions: () => extractProductMentions,
+	generateOperationId: () => generateOperationId,
+	needsClarification: () => needsClarification,
+	normalizeBaseProperties: () => normalizeBaseProperties,
+	normalizeModelConfig: () => normalizeModelConfig,
+	normalizeTokenUsage: () => normalizeTokenUsage,
+	safeStringify: () => safeStringify,
+	sanitizeErrorMessage: () => sanitizeErrorMessage,
+	streamChunkReceived: () => streamChunkReceived,
+	streamCompleted: () => streamCompleted,
+	streamFailed: () => streamFailed,
+	streamStarted: () => streamStarted,
+	toolCallCompleted: () => toolCallCompleted,
+	toolCallFailed: () => toolCallFailed,
+	toolCallStarted: () => toolCallStarted,
+	trackAI: () => trackAI,
+	trackAISDK: () => trackAISDK,
+	truncateArray: () => truncateArray,
+	validateRequiredProperties: () => validateRequiredProperties
+});
+
+//#endregion
+export { ai_exports as t };
+//# sourceMappingURL=ai-YMnynb-t.mjs.map