Roo to main

apps/web-roo-code/src/components/CookieConsentWrapper.tsx

@@ -5,7 +5,7 @@ import ReactCookieConsent from "react-cookie-consent"
 import { Cookie } from "lucide-react"
 import { getDomain } from "tldts"
 import { CONSENT_COOKIE_NAME } from "@roo-code/types"
-import { dispatchConsentEvent } from "@/lib/analytics/consent-manager"
+import { handleConsentAccept, handleConsentReject } from "@/lib/analytics/consent-manager"
 
 /**
  * GDPR-compliant cookie consent banner component
@@ -23,11 +23,11 @@ export function CookieConsentWrapper() {
 	}, [])
 
 	const handleAccept = () => {
-		dispatchConsentEvent(true)
+		handleConsentAccept()
 	}
 
 	const handleDecline = () => {
-		dispatchConsentEvent(false)
+		handleConsentReject()
 	}
 
 	const extraCookieOptions = cookieDomain

apps/web-roo-code/src/components/providers/posthog-provider.tsx

@@ -3,8 +3,8 @@
 import { usePathname, useSearchParams } from "next/navigation"
 import posthog from "posthog-js"
 import { PostHogProvider as OriginalPostHogProvider } from "posthog-js/react"
-import { useEffect, Suspense, useState } from "react"
-import { hasConsent, onConsentChange } from "@/lib/analytics/consent-manager"
+import { useEffect, Suspense } from "react"
+import { hasConsent } from "@/lib/analytics/consent-manager"
 
 function PageViewTracker() {
 	const pathname = usePathname()
@@ -28,11 +28,9 @@ function PageViewTracker() {
 }
 
 export function PostHogProvider({ children }: { children: React.ReactNode }) {
-	const [isInitialized, setIsInitialized] = useState(false)
-
 	useEffect(() => {
-		// Initialize PostHog only on the client side AND when consent is given
-		if (typeof window !== "undefined") {
+		// Initialize PostHog immediately on the client side
+		if (typeof window !== "undefined" && !posthog.__loaded) {
 			const posthogKey = process.env.NEXT_PUBLIC_POSTHOG_KEY
 			const posthogHost = process.env.NEXT_PUBLIC_POSTHOG_HOST
 
@@ -52,48 +50,32 @@ export function PostHogProvider({ children }: { children: React.ReactNode }) {
 				)
 			}
 
-			const initializePosthog = () => {
-				if (!isInitialized) {
-					posthog.init(posthogKey, {
-						api_host: posthogHost || "https://us.i.posthog.com",
-						capture_pageview: false,
-						loaded: (posthogInstance) => {
-							if (process.env.NODE_ENV === "development") {
-								posthogInstance.debug()
-							}
-						},
-						respect_dnt: true, // Respect Do Not Track
-					})
-					setIsInitialized(true)
-				}
-			}
-
-			// Check initial consent status
-			if (hasConsent()) {
-				initializePosthog()
-			}
+			// Check if user has already consented to cookies
+			const userHasConsented = hasConsent()
 
-			// Listen for consent changes
-			const unsubscribe = onConsentChange((consented) => {
-				if (consented && !isInitialized) {
-					initializePosthog()
-				}
+			// Initialize PostHog with appropriate persistence based on consent
+			posthog.init(posthogKey, {
+				api_host: posthogHost || "https://us.i.posthog.com",
+				capture_pageview: false, // We handle pageview tracking manually
+				loaded: (posthogInstance) => {
+					if (process.env.NODE_ENV === "development") {
+						posthogInstance.debug()
+					}
+				},
+				save_referrer: true, // Save referrer information
+				save_campaign_params: true, // Save UTM parameters
+				respect_dnt: true, // Respect Do Not Track
+				persistence: userHasConsented ? "localStorage+cookie" : "memory", // Use localStorage if consented, otherwise memory-only
+				opt_out_capturing_by_default: false, // Start tracking immediately
 			})
-
-			return () => {
-				unsubscribe()
-			}
 		}
-	}, [isInitialized])
+	}, [])
 
-	// Only provide PostHog context if it's initialized
 	return (
 		<OriginalPostHogProvider client={posthog}>
-			{isInitialized && (
-				<Suspense fallback={null}>
-					<PageViewTracker />
-				</Suspense>
-			)}
+			<Suspense fallback={null}>
+				<PageViewTracker />
+			</Suspense>
 			{children}
 		</OriginalPostHogProvider>
 	)

apps/web-roo-code/src/lib/analytics/consent-manager.ts

@@ -5,6 +5,7 @@
 
 import { getCookieConsentValue } from "react-cookie-consent"
 import { CONSENT_COOKIE_NAME } from "@roo-code/types"
+import posthog from "posthog-js"
 
 export const CONSENT_EVENT = "cookieConsentChanged"
 
@@ -45,3 +46,27 @@ export function onConsentChange(callback: (consented: boolean) => void): () => v
 	window.addEventListener(CONSENT_EVENT, handler)
 	return () => window.removeEventListener(CONSENT_EVENT, handler)
 }
+
+/**
+ * Handle user accepting cookies
+ * Opts PostHog back into cookie-based tracking
+ */
+export function handleConsentAccept(): void {
+	if (typeof window !== "undefined" && posthog.__loaded) {
+		// User accepted - ensure localStorage+cookie persistence is enabled
+		posthog.opt_in_capturing()
+		posthog.set_config({
+			persistence: "localStorage+cookie",
+		})
+	}
+	dispatchConsentEvent(true)
+}
+
+/**
+ * Handle user rejecting cookies
+ * Switches PostHog to cookieless (memory-only) mode
+ */
+export function handleConsentReject(): void {
+	// User rejected - stick to cookieless mode
+	dispatchConsentEvent(false)
+}

src/api/providers/anthropic.ts

@@ -230,17 +230,19 @@ export class AnthropicHandler extends BaseProvider implements SingleCompletionHa
 		}
 
 		if (inputTokens > 0 || outputTokens > 0 || cacheWriteTokens > 0 || cacheReadTokens > 0) {
+			const { totalCost } = calculateApiCostAnthropic(
+				this.getModel().info,
+				inputTokens,
+				outputTokens,
+				cacheWriteTokens,
+				cacheReadTokens,
+			)
+
 			yield {
 				type: "usage",
 				inputTokens: 0,
 				outputTokens: 0,
-				totalCost: calculateApiCostAnthropic(
-					this.getModel().info,
-					inputTokens,
-					outputTokens,
-					cacheWriteTokens,
-					cacheReadTokens,
-				),
+				totalCost,
 			}
 		}
 	}

src/api/providers/cerebras.ts

@@ -331,6 +331,7 @@ export class CerebrasHandler extends BaseProvider implements SingleCompletionHan
 		const { info } = this.getModel()
 		// Use actual token usage from the last request
 		const { inputTokens, outputTokens } = this.lastUsage
-		return calculateApiCostOpenAI(info, inputTokens, outputTokens)
+		const { totalCost } = calculateApiCostOpenAI(info, inputTokens, outputTokens)
+		return totalCost
 	}
 }

src/api/providers/deepinfra.ts

@@ -131,9 +131,9 @@ export class DeepInfraHandler extends RouterProvider implements SingleCompletion
 		const cacheWriteTokens = usage?.prompt_tokens_details?.cache_write_tokens || 0
 		const cacheReadTokens = usage?.prompt_tokens_details?.cached_tokens || 0
 
-		const totalCost = modelInfo
+		const { totalCost } = modelInfo
 			? calculateApiCostOpenAI(modelInfo, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens)
-			: 0
+			: { totalCost: 0 }
 
 		return {
 			type: "usage",

src/api/providers/groq.ts

@@ -64,7 +64,7 @@ export class GroqHandler extends BaseOpenAiCompatibleProvider<GroqModelId> {
 		const cacheWriteTokens = 0
 
 		// Calculate cost using OpenAI-compatible cost calculation
-		const totalCost = calculateApiCostOpenAI(info, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens)
+		const { totalCost } = calculateApiCostOpenAI(info, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens)
 
 		yield {
 			type: "usage",

src/api/providers/lite-llm.ts

@@ -165,22 +165,23 @@ export class LiteLLMHandler extends RouterProvider implements SingleCompletionHa
 					(lastUsage as any).prompt_cache_hit_tokens ||
 					0
 
+				const { totalCost } = calculateApiCostOpenAI(
+					info,
+					lastUsage.prompt_tokens || 0,
+					lastUsage.completion_tokens || 0,
+					cacheWriteTokens,
+					cacheReadTokens,
+				)
+
 				const usageData: ApiStreamUsageChunk = {
 					type: "usage",
 					inputTokens: lastUsage.prompt_tokens || 0,
 					outputTokens: lastUsage.completion_tokens || 0,
 					cacheWriteTokens: cacheWriteTokens > 0 ? cacheWriteTokens : undefined,
 					cacheReadTokens: cacheReadTokens > 0 ? cacheReadTokens : undefined,
+					totalCost,
 				}
 
-				usageData.totalCost = calculateApiCostOpenAI(
-					info,
-					usageData.inputTokens,
-					usageData.outputTokens,
-					usageData.cacheWriteTokens || 0,
-					usageData.cacheReadTokens || 0,
-				)
-
 				yield usageData
 			}
 		} catch (error) {

src/api/providers/openai-native.ts

@@ -99,8 +99,8 @@ export class OpenAiNativeHandler extends BaseProvider implements SingleCompletio
 		const effectiveInfo = this.applyServiceTierPricing(model.info, effectiveTier)
 
 		// Pass total input tokens directly to calculateApiCostOpenAI
-		// The function handles subtracting both cache reads and writes internally (see shared/cost.ts:46)
-		const totalCost = calculateApiCostOpenAI(
+		// The function handles subtracting both cache reads and writes internally
+		const { totalCost } = calculateApiCostOpenAI(
 			effectiveInfo,
 			totalInputTokens,
 			totalOutputTokens,

src/api/providers/requesty.ts

@@ -85,9 +85,9 @@ export class RequestyHandler extends BaseProvider implements SingleCompletionHan
 		const outputTokens = requestyUsage?.completion_tokens || 0
 		const cacheWriteTokens = requestyUsage?.prompt_tokens_details?.caching_tokens || 0
 		const cacheReadTokens = requestyUsage?.prompt_tokens_details?.cached_tokens || 0
-		const totalCost = modelInfo
+		const { totalCost } = modelInfo
 			? calculateApiCostOpenAI(modelInfo, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens)
-			: 0
+			: { totalCost: 0 }
 
 		return {
 			type: "usage",

src/api/providers/zgsm.ts

@@ -359,7 +359,8 @@ export class ZgsmAiHandler extends BaseProvider implements SingleCompletionHandl
 	): OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming {
 		const requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming = {
 			model: modelId,
-			temperature: this.options.modelTemperature ?? (isDeepseekReasoner ? DEEP_SEEK_DEFAULT_TEMPERATURE : 0),
+			temperature:
+				this.options.modelTemperature ?? (isDeepseekReasoner ? DEEP_SEEK_DEFAULT_TEMPERATURE : undefined),
 			messages,
 			stream: true as const,
 			...(isGrokXAI ? {} : { stream_options: { include_usage: true } }),

src/core/task/Task.ts

@@ -74,7 +74,7 @@ import { RooTerminalProcess } from "../../integrations/terminal/types"
 import { TerminalRegistry } from "../../integrations/terminal/TerminalRegistry"
 
 // utils
-import { calculateApiCostAnthropic } from "../../shared/cost"
+import { calculateApiCostAnthropic, calculateApiCostOpenAI } from "../../shared/cost"
 import { getWorkspacePath } from "../../utils/path"
 
 // prompts
@@ -1908,21 +1908,35 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 					}
 
 					const existingData = JSON.parse(this.clineMessages[lastApiReqIndex].text || "{}")
+
+					// Calculate total tokens and cost using provider-aware function
+					const modelId = getModelId(this.apiConfiguration)
+					const apiProtocol = getApiProtocol(this.apiConfiguration.apiProvider, modelId)
+
+					const costResult =
+						apiProtocol === "anthropic"
+							? calculateApiCostAnthropic(
+									this.api.getModel().info,
+									inputTokens,
+									outputTokens,
+									cacheWriteTokens,
+									cacheReadTokens,
+								)
+							: calculateApiCostOpenAI(
+									this.api.getModel().info,
+									inputTokens,
+									outputTokens,
+									cacheWriteTokens,
+									cacheReadTokens,
+								)
+
 					this.clineMessages[lastApiReqIndex].text = JSON.stringify({
 						...existingData,
-						tokensIn: inputTokens,
-						tokensOut: outputTokens,
+						tokensIn: costResult.totalInputTokens,
+						tokensOut: costResult.totalOutputTokens,
 						cacheWrites: cacheWriteTokens,
 						cacheReads: cacheReadTokens,
-						cost:
-							totalCost ??
-							calculateApiCostAnthropic(
-								this.api.getModel().info,
-								inputTokens,
-								outputTokens,
-								cacheWriteTokens,
-								cacheReadTokens,
-							),
+						cost: totalCost ?? costResult.totalCost,
 						cancelReason,
 						streamingFailedMessage,
 					} satisfies ClineApiReqInfo)
@@ -2129,21 +2143,34 @@ export class Task extends EventEmitter<TaskEvents> implements TaskLike {
 									await this.updateClineMessage(apiReqMessage)
 								}
 
-								// Capture telemetry
+								// Capture telemetry with provider-aware cost calculation
+								const modelId = getModelId(this.apiConfiguration)
+								const apiProtocol = getApiProtocol(this.apiConfiguration.apiProvider, modelId)
+
+								// Use the appropriate cost function based on the API protocol
+								const costResult =
+									apiProtocol === "anthropic"
+										? calculateApiCostAnthropic(
+												this.api.getModel().info,
+												tokens.input,
+												tokens.output,
+												tokens.cacheWrite,
+												tokens.cacheRead,
+											)
+										: calculateApiCostOpenAI(
+												this.api.getModel().info,
+												tokens.input,
+												tokens.output,
+												tokens.cacheWrite,
+												tokens.cacheRead,
+											)
+
 								TelemetryService.instance.captureLlmCompletion(this.taskId, {
-									inputTokens: tokens.input,
-									outputTokens: tokens.output,
+									inputTokens: costResult.totalInputTokens,
+									outputTokens: costResult.totalOutputTokens,
 									cacheWriteTokens: tokens.cacheWrite,
 									cacheReadTokens: tokens.cacheRead,
-									cost:
-										tokens.total ??
-										calculateApiCostAnthropic(
-											this.api.getModel().info,
-											tokens.input,
-											tokens.output,
-											tokens.cacheWrite,
-											tokens.cacheRead,
-										),
+									cost: tokens.total ?? costResult.totalCost,
 								})
 							}
 						}