remove commented out logger.debug blocks per PR review request

Author: Smartsheet-JB-Brown

src/api/providers/bedrock.ts

@@ -187,7 +187,6 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 		const usePromptCache = Boolean(this.options.awsUsePromptCache && this.supportsAwsPromptCache(modelConfig))
 
 		// Generate a conversation ID based on the first few messages to maintain cache consistency
-		// This is a simple approach - in a real application, you might want to use a more robust ID system
 		const conversationId =
 			messages.length > 0
 				? `conv_${messages[0].role}_${
@@ -232,16 +231,6 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 				10 * 60 * 1000,
 			)
 
-			// Log the payload for debugging custom ARN issues
-			if (this.options.awsCustomArn) {
-				// logger.debug("Using custom ARN for Bedrock request", {
-				// 	ctx: "bedrock",
-				// 	customArn: this.options.awsCustomArn,
-				// 	clientRegion: this.client.config.region,
-				// 	payload: JSON.stringify(payload, null, 2),
-				// })
-			}
-
 			const command = new ConverseStreamCommand(payload)
 			const response = await this.client.send(command, {
 				abortSignal: controller.signal,
@@ -274,15 +263,6 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 					const cacheReadTokens = usage.cacheReadInputTokens || usage.cacheReadInputTokenCount || 0
 					const cacheWriteTokens = usage.cacheWriteInputTokens || usage.cacheWriteInputTokenCount || 0
 
-					// logger.debug("Bedrock usage amounts before yielding", {
-					// 	ctx: "bedrock",
-					// 	inputTokens: usage.inputTokens || 0,
-					// 	outputTokens: usage.outputTokens || 0,
-					// 	cacheReadTokens,
-					// 	cacheWriteTokens,
-					// 	modelId: modelId,
-					// })
-
 					// Always include all available token information
 					yield {
 						type: "usage",
@@ -317,15 +297,6 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 							const cacheWriteTokens =
 								routerUsage.cacheWriteTokens || routerUsage.cacheWriteInputTokenCount || 0
 
-							// logger.debug("Bedrock prompt router usage amounts before yielding", {
-							// 	ctx: "bedrock",
-							// 	inputTokens: routerUsage.inputTokens || 0,
-							// 	outputTokens: routerUsage.outputTokens || 0,
-							// 	cacheReadTokens,
-							// 	cacheWriteTokens,
-							// 	invokedModelId: streamEvent.trace.promptRouter.invokedModelId,
-							// })
-
 							yield {
 								type: "usage",
 								inputTokens: routerUsage.inputTokens || 0,
@@ -433,11 +404,7 @@ export class AwsBedrockHandler extends BaseProvider implements SingleCompletionH
 				response.output.message.content[0].text.trim().length > 0
 			) {
 				try {
-					//const outputStr = new TextDecoder().decode(response.output.message.content[0].text)
-					//const output = JSON.parse(outputStr)
-					//if (response.output.message.content[0].text) {
 					return response.output.message.content[0].text
-					//}
 				} catch (parseError) {
 					logger.error("Failed to parse Bedrock response", {
 						ctx: "bedrock",

src/api/transform/cache-strategy/base-strategy.ts

@@ -148,24 +148,10 @@ export abstract class CacheStrategy {
 	 */
 	protected applyCachePoints(messages: Message[], placements: CachePointPlacement[]): Message[] {
 		const result: Message[] = []
-
-		// logger.debug("Applying cache points to messages", {
-		// 	ctx: "cache-strategy",
-		// 	messageCount: messages.length,
-		// 	placementCount: placements.length,
-		// 	placements: placements.map((p) => ({ index: p.index, tokensCovered: p.tokensCovered })),
-		// })
-
 		for (let i = 0; i < messages.length; i++) {
 			const placement = placements.find((p) => p.index === i)
 
 			if (placement) {
-				// logger.debug("Adding cache point to message", {
-				// 	ctx: "cache-strategy",
-				// 	messageIndex: i,
-				// 	messageRole: messages[i].role,
-				// 	tokensCovered: placement.tokensCovered,
-				// })
 				messages[i].content?.push(this.createCachePoint())
 			}
 			result.push(messages[i])

src/api/transform/cache-strategy/multi-point-strategy.ts

@@ -14,11 +14,6 @@ export class MultiPointStrategy extends CacheStrategy {
 	public determineOptimalCachePoints(): CacheResult {
 		// If prompt caching is disabled or no messages, return without cache points
 		if (!this.config.usePromptCache || this.config.messages.length === 0) {
-			// logger.debug("Cache points not used: prompt caching disabled or no messages", {
-			// 	ctx: "cache-strategy",
-			// 	usePromptCache: this.config.usePromptCache,
-			// 	messageCount: this.config.messages.length,
-			// })
 			return this.formatWithoutCachePoints()
 		}
 
@@ -27,71 +22,26 @@ export class MultiPointStrategy extends CacheStrategy {
 		const minTokensPerPoint = this.config.modelInfo.minTokensPerCachePoint
 		let remainingCachePoints: number = this.config.modelInfo.maxCachePoints
 
-		// logger.debug("Starting cache point determination", {
-		// 	ctx: "cache-strategy",
-		// 	supportsSystemCache,
-		// 	supportsMessageCache,
-		// 	minTokensPerPoint,
-		// 	maxCachePoints: this.config.modelInfo.maxCachePoints,
-		// 	remainingCachePoints,
-		// 	messageCount: this.config.messages.length,
-		// })
-
 		// First, determine if we'll use a system cache point
 		const useSystemCache =
 			supportsSystemCache && this.config.systemPrompt && this.meetsMinTokenThreshold(this.systemTokenCount)
 
-		// logger.debug("System cache point evaluation", {
-		// 	ctx: "cache-strategy",
-		// 	supportsSystemCache,
-		// 	hasSystemPrompt: !!this.config.systemPrompt,
-		// 	systemTokenCount: this.systemTokenCount,
-		// 	minTokensRequired: this.config.modelInfo.minTokensPerCachePoint,
-		// 	meetsThreshold: this.meetsMinTokenThreshold(this.systemTokenCount),
-		// 	useSystemCache,
-		// })
-
 		// Handle system blocks
 		let systemBlocks: SystemContentBlock[] = []
 		if (this.config.systemPrompt) {
 			systemBlocks = [{ text: this.config.systemPrompt } as unknown as SystemContentBlock]
 			if (useSystemCache) {
-				// logger.debug("Adding cache point after system prompt", {
-				// 	ctx: "cache-strategy",
-				// 	systemTokenCount: this.systemTokenCount,
-				// })
 				systemBlocks.push(this.createCachePoint() as unknown as SystemContentBlock)
 				remainingCachePoints--
 			}
 		}
 
 		// If message caching isn't supported, return with just system caching
 		if (!supportsMessageCache) {
-			// logger.debug("Message caching not supported, using system caching only", {
-			// 	ctx: "cache-strategy",
-			// 	supportsMessageCache,
-			// })
 			return this.formatResult(systemBlocks, this.messagesToContentBlocks(this.config.messages))
 		}
 
-		// Determine optimal cache point placements for messages
-		// logger.debug("Determining message cache points", {
-		// 	ctx: "cache-strategy",
-		// 	minTokensPerPoint,
-		// 	remainingCachePoints,
-		// 	messageCount: this.config.messages.length,
-		// 	hasPreviousPlacements: !!this.config.previousCachePointPlacements,
-		// 	previousPlacementsCount: this.config.previousCachePointPlacements?.length || 0,
-		// })
-
 		const placements = this.determineMessageCachePoints(minTokensPerPoint, remainingCachePoints)
-
-		// logger.debug("Cache point placements determined", {
-		// 	ctx: "cache-strategy",
-		// 	placementsCount: placements.length,
-		// 	placements: placements.map((p) => ({ index: p.index, tokensCovered: p.tokensCovered })),
-		// })
-
 		const messages = this.messagesToContentBlocks(this.config.messages)
 		let cacheResult = this.formatResult(systemBlocks, this.applyCachePoints(messages, placements))
 
@@ -115,62 +65,29 @@ export class MultiPointStrategy extends CacheStrategy {
 		remainingCachePoints: number,
 	): CachePointPlacement[] {
 		if (this.config.messages.length <= 1) {
-			// logger.debug("Not enough messages for cache points", {
-			// 	ctx: "cache-strategy",
-			// 	messageCount: this.config.messages.length,
-			// })
 			return []
 		}
 
 		const placements: CachePointPlacement[] = []
 		const totalMessages = this.config.messages.length
 		const previousPlacements = this.config.previousCachePointPlacements || []
 
-		// logger.debug("Starting message cache point determination", {
-		// 	ctx: "cache-strategy",
-		// 	totalMessages,
-		// 	previousPlacementsCount: previousPlacements.length,
-		// 	remainingCachePoints,
-		// })
-
 		// Special case: If previousPlacements is empty, place initial cache points
 		if (previousPlacements.length === 0) {
-			// logger.debug("No previous placements, determining initial cache points", {
-			// 	ctx: "cache-strategy",
-			// })
-
 			let currentIndex = 0
 
 			while (currentIndex < totalMessages && remainingCachePoints > 0) {
-				// logger.debug("Finding optimal placement for range", {
-				// 	ctx: "cache-strategy",
-				// 	startIndex: currentIndex,
-				// 	endIndex: totalMessages - 1,
-				// 	minTokensPerPoint,
-				// })
-
 				const newPlacement = this.findOptimalPlacementForRange(
 					currentIndex,
 					totalMessages - 1,
 					minTokensPerPoint,
 				)
 
 				if (newPlacement) {
-					// logger.debug("Found optimal placement", {
-					// 	ctx: "cache-strategy",
-					// 	placementIndex: newPlacement.index,
-					// 	tokensCovered: newPlacement.tokensCovered,
-					// })
-
 					placements.push(newPlacement)
 					currentIndex = newPlacement.index + 1
 					remainingCachePoints--
 				} else {
-					// logger.debug("No suitable placement found in range", {
-					// 	ctx: "cache-strategy",
-					// 	startIndex: currentIndex,
-					// 	endIndex: totalMessages - 1,
-					// })
 					break
 				}
 			}
@@ -244,16 +161,6 @@ export class MultiPointStrategy extends CacheStrategy {
 				const requiredPercentageIncrease = 1.2 // 20% increase required
 				const requiredTokenThreshold = smallestGap * requiredPercentageIncrease
 
-				// logger.debug("Cache point decision", {
-				// 	ctx: "cache-strategy",
-				// 	newMessagesTokens,
-				// 	smallestGap,
-				// 	requiredTokenThreshold,
-				// 	shouldCombine: newMessagesTokens >= requiredTokenThreshold,
-				// 	lastPreviousIndex,
-				// 	totalMessages,
-				// })
-
 				if (newMessagesTokens >= requiredTokenThreshold) {
 					// It's beneficial to combine cache points since new messages have significantly more tokens
 					logger.info("Combining cache points is beneficial", {
@@ -348,11 +255,6 @@ export class MultiPointStrategy extends CacheStrategy {
 		minTokensPerPoint: number,
 	): CachePointPlacement | null {
 		if (startIndex >= endIndex) {
-			// logger.debug("Invalid range for cache point placement", {
-			// 	ctx: "cache-strategy",
-			// 	startIndex,
-			// 	endIndex,
-			// })
 			return null
 		}
 
@@ -365,14 +267,6 @@ export class MultiPointStrategy extends CacheStrategy {
 			}
 		}
 
-		// logger.debug("Finding last user message in range", {
-		// 	ctx: "cache-strategy",
-		// 	startIndex,
-		// 	endIndex,
-		// 	lastUserMessageIndex,
-		// 	foundUserMessage: lastUserMessageIndex >= 0,
-		// })
-
 		if (lastUserMessageIndex >= 0) {
 			// Calculate the total tokens covered from the previous cache point (or start of conversation)
 			// to this cache point. This ensures tokensCovered represents the full span of tokens
@@ -395,34 +289,10 @@ export class MultiPointStrategy extends CacheStrategy {
 				.slice(tokenStartIndex, lastUserMessageIndex + 1)
 				.reduce((acc, curr) => acc + this.estimateTokenCount(curr), 0)
 
-			// logger.debug("Evaluating potential cache point", {
-			// 	ctx: "cache-strategy",
-			// 	messageIndex: lastUserMessageIndex,
-			// 	previousCachePointIndex,
-			// 	tokenStartIndex,
-			// 	totalTokensCovered,
-			// 	minTokensPerPoint,
-			// 	meetsThreshold: totalTokensCovered >= minTokensPerPoint,
-			// })
-
 			// Guard clause: ensure we have enough tokens to justify a cache point
 			if (totalTokensCovered < minTokensPerPoint) {
-				// logger.debug("Not enough tokens for cache point", {
-				// 	ctx: "cache-strategy",
-				// 	totalTokensCovered,
-				// 	minTokensPerPoint,
-				// 	messageIndex: lastUserMessageIndex,
-				// })
 				return null
 			}
-
-			// logger.debug("Creating cache point placement", {
-			// 	ctx: "cache-strategy",
-			// 	index: lastUserMessageIndex,
-			// 	tokensCovered: totalTokensCovered,
-			// 	messageRole: this.config.messages[lastUserMessageIndex].role,
-			// })
-
 			return {
 				index: lastUserMessageIndex,
 				type: "message",