@inkeep/agents-run-api 0.0.0-dev-20260105192809 → 0.0.0-dev-20260105201718

package/dist/services/ConversationCompressor.d.ts

@@ -0,0 +1,32 @@
+import { BaseCompressor, CompressionConfig, CompressionResult } from "./BaseCompressor.js";
+import { ModelSettings } from "@inkeep/agents-core";
+
+//#region src/services/ConversationCompressor.d.ts
+
+/**
+ * Conversation-level compressor
+ * Compresses entire conversations for long-term storage or analysis
+ */
+declare class ConversationCompressor extends BaseCompressor {
+  constructor(sessionId: string, conversationId: string, tenantId: string, projectId: string, config?: CompressionConfig, summarizerModel?: ModelSettings, baseModel?: ModelSettings);
+  /**
+   * Get compression type for this compressor
+   */
+  getCompressionType(): 'conversation_level';
+  /**
+   * Check if compression is needed based on total context size exceeding conversation limits
+   */
+  isCompressionNeeded(messages: any[]): boolean;
+  /**
+   * Perform conversation-level compression
+   * Unlike mid-generation, this compresses ALL messages in the conversation
+   */
+  compress(messages: any[]): Promise<CompressionResult>;
+  /**
+   * Override createConversationSummary for conversation-level compression
+   * Uses specialized conversation history distillation instead of the base implementation
+   */
+  protected createConversationSummary(messages: any[], toolCallToArtifactMap: Record<string, string>): Promise<any>;
+}
+//#endregion
+export { ConversationCompressor };

package/dist/services/ConversationCompressor.js

@@ -0,0 +1,91 @@
+import { getLogger } from "../logger.js";
+import { distillConversationHistory } from "../tools/distill-conversation-history-tool.js";
+import { BaseCompressor, getModelAwareCompressionConfig } from "./BaseCompressor.js";
+
+//#region src/services/ConversationCompressor.ts
+const logger = getLogger("ConversationCompressor");
+/**
+* Conversation-level compressor
+* Compresses entire conversations for long-term storage or analysis
+*/
+var ConversationCompressor = class extends BaseCompressor {
+	constructor(sessionId, conversationId, tenantId, projectId, config, summarizerModel, baseModel) {
+		const compressionConfig = config || getModelAwareCompressionConfig(summarizerModel, .5);
+		super(sessionId, conversationId, tenantId, projectId, compressionConfig, summarizerModel, baseModel);
+	}
+	/**
+	* Get compression type for this compressor
+	*/
+	getCompressionType() {
+		return "conversation_level";
+	}
+	/**
+	* Check if compression is needed based on total context size exceeding conversation limits
+	*/
+	isCompressionNeeded(messages) {
+		const contextSize = this.calculateContextSize(messages);
+		const remaining = this.config.hardLimit - contextSize;
+		const needsCompression = remaining <= this.config.safetyBuffer;
+		logger.debug({
+			sessionId: this.sessionId,
+			contextSize,
+			hardLimit: this.config.hardLimit,
+			safetyBuffer: this.config.safetyBuffer,
+			remaining,
+			needsCompression
+		}, "Checking conversation compression criteria");
+		return needsCompression;
+	}
+	/**
+	* Perform conversation-level compression
+	* Unlike mid-generation, this compresses ALL messages in the conversation
+	*/
+	async compress(messages) {
+		const contextSizeBefore = this.calculateContextSize(messages);
+		logger.info({
+			sessionId: this.sessionId,
+			messageCount: messages.length,
+			contextSize: contextSizeBefore
+		}, "CONVERSATION COMPRESSION: Starting compression");
+		const toolCallToArtifactMap = await this.saveToolResultsAsArtifacts(messages, 0);
+		const summary = await this.createConversationSummary(messages, toolCallToArtifactMap);
+		const contextSizeAfter = this.estimateTokens(JSON.stringify(summary));
+		this.recordCompressionEvent({
+			reason: "automatic",
+			messageCount: messages.length,
+			artifactCount: Object.keys(toolCallToArtifactMap).length,
+			contextSizeBefore,
+			contextSizeAfter,
+			compressionType: this.getCompressionType()
+		});
+		logger.info({
+			sessionId: this.sessionId,
+			artifactsCreated: Object.keys(toolCallToArtifactMap).length,
+			messageCount: messages.length,
+			contextSizeBefore,
+			contextSizeAfter,
+			compressionRatio: contextSizeAfter / contextSizeBefore,
+			artifactIds: Object.values(toolCallToArtifactMap)
+		}, "CONVERSATION COMPRESSION: Compression completed successfully");
+		return {
+			artifactIds: Object.values(toolCallToArtifactMap),
+			summary
+		};
+	}
+	/**
+	* Override createConversationSummary for conversation-level compression
+	* Uses specialized conversation history distillation instead of the base implementation
+	*/
+	async createConversationSummary(messages, toolCallToArtifactMap) {
+		if (!this.summarizerModel) throw new Error("Summarizer model is required for conversation history compression");
+		return await distillConversationHistory({
+			messages,
+			conversationId: this.conversationId,
+			summarizerModel: this.summarizerModel,
+			toolCallToArtifactMap
+		});
+	}
+};
+
+//#endregion
+export { ConversationCompressor };

package/dist/services/MidGenerationCompressor.d.ts

@@ -1,91 +1,63 @@
+import { BaseCompressor, CompressionConfig, CompressionResult } from "./BaseCompressor.js";
 import { ModelSettings } from "@inkeep/agents-core";
 
 //#region src/services/MidGenerationCompressor.d.ts
-interface CompressionConfig {
-  hardLimit: number;
-  safetyBuffer: number;
-  enabled?: boolean;
-}
-/**
- * Get compression config from environment variables
- */
-declare function getCompressionConfigFromEnv(): CompressionConfig;
+
 /**
- * Simple mid-generation compressor
- * Compresses context when generate() steps get too large
+ * Mid-generation compressor
+ * Compresses context when generate() steps get too large with manual compression support
  */
-declare class MidGenerationCompressor {
-  private sessionId;
-  private conversationId;
-  private tenantId;
-  private projectId;
-  private config;
-  private summarizerModel?;
-  private baseModel?;
+declare class MidGenerationCompressor extends BaseCompressor {
   private shouldCompress;
-  private processedToolCalls;
   private lastProcessedMessageIndex;
-  private cumulativeSummary;
-  constructor(sessionId: string, conversationId: string, tenantId: string, projectId: string, config: CompressionConfig, summarizerModel?: ModelSettings | undefined, baseModel?: ModelSettings | undefined);
-  /**
-   * Get the hard limit for compression decisions
-   */
-  getHardLimit(): number;
-  /**
-   * Estimate tokens (4 chars = 1 token)
-   */
-  private estimateTokens;
+  constructor(sessionId: string, conversationId: string, tenantId: string, projectId: string, config?: CompressionConfig, summarizerModel?: ModelSettings, baseModel?: ModelSettings);
   /**
-   * Calculate total context size
+   * Get compression type for this compressor
    */
-  private calculateContextSize;
+  getCompressionType(): 'mid_generation';
   /**
    * Manual compression request from LLM tool
    */
   requestManualCompression(reason?: string): void;
   /**
    * Check if compression is needed (either automatic or manual)
+   * Supports manual compression requests unique to mid-generation
    */
   isCompressionNeeded(messages: any[]): boolean;
   /**
-   * Perform compression: save all tool results as artifacts and create summary
-   */
-  compress(messages: any[]): Promise<{
-    artifactIds: string[];
-    summary: any;
-  }>;
-  /**
-   * 1. Save NEW tool results as artifacts (only process messages since last compression)
+   * Perform mid-generation compression with incremental processing
+   * Uses base class functionality with mid-generation specific logic
    */
-  private saveToolResultsAsArtifacts;
-  /**
-   * 3. Create conversation summary with artifact references
-   */
-  private createConversationSummary;
-  /**
-   * Extract text messages and convert tool calls to descriptive text
-   * Avoids API tool-call/tool-result pairing issues while preserving context
-   */
-  private extractTextMessages;
-  /**
-   * Check if tool result data is effectively empty
-   */
-  private isEmpty;
-  /**
-   * Recursively remove _structureHints from an object
-   */
-  private removeStructureHints;
+  compress(messages: any[]): Promise<CompressionResult>;
   /**
    * Get current state for debugging
    */
   getState(): {
     shouldCompress: boolean;
+    lastProcessedMessageIndex: number;
     config: CompressionConfig;
+    processedToolCalls: string[];
+    cumulativeSummary: {
+      type: "conversation_summary_v1";
+      high_level: string;
+      user_intent: string;
+      decisions: string[];
+      open_questions: string[];
+      next_steps: {
+        for_agent: string[];
+        for_user: string[];
+      };
+      session_id?: string | null | undefined;
+      related_artifacts?: {
+        id: string;
+        name: string;
+        tool_name: string;
+        tool_call_id: string;
+        content_type: string;
+        key_findings: string[];
+      }[] | undefined;
+    } | null;
   };
-  /**
-   * Get the current compression summary
-   */
-  getCompressionSummary(): any;
 }
 //#endregion
-export { CompressionConfig, MidGenerationCompressor, getCompressionConfigFromEnv };
+export { MidGenerationCompressor };

package/dist/services/MidGenerationCompressor.js

@@ -1,73 +1,24 @@
 import { getLogger } from "../logger.js";
-import { agentSessionManager } from "./AgentSession.js";
-import { distillConversation } from "../tools/distill-conversation-tool.js";
-import { randomUUID } from "crypto";
+import { BaseCompressor, getModelAwareCompressionConfig } from "./BaseCompressor.js";
 
 //#region src/services/MidGenerationCompressor.ts
 const logger = getLogger("MidGenerationCompressor");
 /**
-* Get compression config from environment variables
+* Mid-generation compressor
+* Compresses context when generate() steps get too large with manual compression support
 */
-function getCompressionConfigFromEnv() {
-	return {
-		hardLimit: parseInt(process.env.AGENTS_COMPRESSION_HARD_LIMIT || "120000"),
-		safetyBuffer: parseInt(process.env.AGENTS_COMPRESSION_SAFETY_BUFFER || "20000"),
-		enabled: process.env.AGENTS_COMPRESSION_ENABLED !== "false"
-	};
-}
-/**
-* Simple mid-generation compressor
-* Compresses context when generate() steps get too large
-*/
-var MidGenerationCompressor = class {
+var MidGenerationCompressor = class extends BaseCompressor {
 	shouldCompress = false;
-	processedToolCalls = /* @__PURE__ */ new Set();
 	lastProcessedMessageIndex = 0;
-	cumulativeSummary = null;
 	constructor(sessionId, conversationId, tenantId, projectId, config, summarizerModel, baseModel) {
-		this.sessionId = sessionId;
-		this.conversationId = conversationId;
-		this.tenantId = tenantId;
-		this.projectId = projectId;
-		this.config = config;
-		this.summarizerModel = summarizerModel;
-		this.baseModel = baseModel;
-	}
-	/**
-	* Get the hard limit for compression decisions
-	*/
-	getHardLimit() {
-		return this.config.hardLimit;
-	}
-	/**
-	* Estimate tokens (4 chars = 1 token)
-	*/
-	estimateTokens(content) {
-		const text = typeof content === "string" ? content : JSON.stringify(content);
-		return Math.ceil(text.length / 4);
+		const compressionConfig = config || getModelAwareCompressionConfig(summarizerModel);
+		super(sessionId, conversationId, tenantId, projectId, compressionConfig, summarizerModel, baseModel);
 	}
 	/**
-	* Calculate total context size
+	* Get compression type for this compressor
 	*/
-	calculateContextSize(messages) {
-		return messages.reduce((total, msg) => {
-			let msgTokens = 0;
-			if (Array.isArray(msg.content)) {
-				for (const block of msg.content) if (block.type === "text") msgTokens += this.estimateTokens(block.text || "");
-				else if (block.type === "tool-call") msgTokens += this.estimateTokens(JSON.stringify({
-					toolCallId: block.toolCallId,
-					toolName: block.toolName,
-					input: block.input
-				}));
-				else if (block.type === "tool-result") msgTokens += this.estimateTokens(JSON.stringify({
-					toolCallId: block.toolCallId,
-					toolName: block.toolName,
-					output: block.output
-				}));
-			} else if (typeof msg.content === "string") msgTokens += this.estimateTokens(msg.content);
-			else if (msg.content) msgTokens += this.estimateTokens(JSON.stringify(msg.content));
-			return total + msgTokens;
-		}, 0);
+	getCompressionType() {
+		return "mid_generation";
 	}
 	/**
 	* Manual compression request from LLM tool
@@ -81,14 +32,27 @@ var MidGenerationCompressor = class {
 	}
 	/**
 	* Check if compression is needed (either automatic or manual)
+	* Supports manual compression requests unique to mid-generation
 	*/
 	isCompressionNeeded(messages) {
 		if (this.shouldCompress) return true;
 		const contextSize = this.calculateContextSize(messages);
-		return this.config.hardLimit - contextSize <= this.config.safetyBuffer;
+		const remaining = this.config.hardLimit - contextSize;
+		const needsCompression = remaining <= this.config.safetyBuffer;
+		logger.debug({
+			sessionId: this.sessionId,
+			contextSize,
+			hardLimit: this.config.hardLimit,
+			safetyBuffer: this.config.safetyBuffer,
+			remaining,
+			needsCompression,
+			manualRequest: this.shouldCompress
+		}, "Checking mid-generation compression criteria");
+		return needsCompression;
 	}
 	/**
-	* Perform compression: save all tool results as artifacts and create summary
+	* Perform mid-generation compression with incremental processing
+	* Uses base class functionality with mid-generation specific logic
 	*/
 	async compress(messages) {
 		const contextSizeBefore = this.calculateContextSize(messages);
@@ -96,280 +60,45 @@ var MidGenerationCompressor = class {
 			sessionId: this.sessionId,
 			messageCount: messages.length,
 			contextSize: contextSizeBefore
-		}, "COMPRESSION: Starting compression");
-		const toolResultCount = messages.reduce((count, msg) => {
-			if (Array.isArray(msg.content)) return count + msg.content.filter((block) => block.type === "tool-result").length;
-			return count;
-		}, 0);
-		logger.debug({ toolResultCount }, "Tool results found for compression");
-		const toolCallToArtifactMap = await this.saveToolResultsAsArtifacts(messages);
+		}, "MID-GENERATION COMPRESSION: Starting compression");
+		const toolCallToArtifactMap = await this.saveToolResultsAsArtifacts(messages, this.lastProcessedMessageIndex);
 		const summary = await this.createConversationSummary(messages, toolCallToArtifactMap);
 		const contextSizeAfter = this.estimateTokens(JSON.stringify(summary));
-		const session = agentSessionManager.getSession(this.sessionId);
-		if (session) {
-			const wasManualRequest = this.shouldCompress;
-			session.recordEvent("compression", this.sessionId, {
-				reason: wasManualRequest ? "manual" : "automatic",
-				messageCount: messages.length,
-				artifactCount: Object.keys(toolCallToArtifactMap).length,
-				contextSizeBefore,
-				contextSizeAfter,
-				compressionType: "mid_generation"
-			});
-		}
+		this.recordCompressionEvent({
+			reason: this.shouldCompress ? "manual" : "automatic",
+			messageCount: messages.length,
+			artifactCount: Object.keys(toolCallToArtifactMap).length,
+			contextSizeBefore,
+			contextSizeAfter,
+			compressionType: this.getCompressionType()
+		});
 		this.shouldCompress = false;
+		this.lastProcessedMessageIndex = messages.length;
 		logger.info({
 			sessionId: this.sessionId,
 			artifactsCreated: Object.keys(toolCallToArtifactMap).length,
 			messageCount: messages.length,
 			contextSizeBefore,
 			contextSizeAfter,
+			compressionRatio: contextSizeAfter / contextSizeBefore,
 			artifactIds: Object.values(toolCallToArtifactMap)
-		}, "COMPRESSION: Compression completed successfully");
+		}, "MID-GENERATION COMPRESSION: Compression completed successfully");
 		return {
 			artifactIds: Object.values(toolCallToArtifactMap),
 			summary
 		};
 	}
 	/**
-	* 1. Save NEW tool results as artifacts (only process messages since last compression)
-	*/
-	async saveToolResultsAsArtifacts(messages) {
-		const session = agentSessionManager.getSession(this.sessionId);
-		if (!session) throw new Error(`No session found: ${this.sessionId}`);
-		const toolCallToArtifactMap = {};
-		const newMessages = messages.slice(this.lastProcessedMessageIndex);
-		logger.debug({
-			totalMessages: messages.length,
-			newMessages: newMessages.length,
-			startIndex: this.lastProcessedMessageIndex
-		}, "Starting compression artifact processing");
-		for (const message of newMessages) if (Array.isArray(message.content)) {
-			for (const block of message.content) if (block.type === "tool-result") {
-				if (block.toolName === "get_reference_artifact" || block.toolName === "thinking_complete") {
-					logger.debug({
-						toolCallId: block.toolCallId,
-						toolName: block.toolName
-					}, "Skipping special tool - not creating artifacts");
-					this.processedToolCalls.add(block.toolCallId);
-					continue;
-				}
-				if (this.processedToolCalls.has(block.toolCallId)) {
-					logger.debug({
-						toolCallId: block.toolCallId,
-						toolName: block.toolName
-					}, "Skipping already processed tool call");
-					continue;
-				}
-				const artifactId = `compress_${block.toolName || "tool"}_${block.toolCallId || Date.now()}_${randomUUID().slice(0, 8)}`;
-				logger.debug({
-					artifactId,
-					toolName: block.toolName,
-					toolCallId: block.toolCallId
-				}, "Saving compression artifact");
-				let toolInput = null;
-				if (Array.isArray(message.content)) toolInput = message.content.find((b) => b.type === "tool-call" && b.toolCallId === block.toolCallId)?.input;
-				const cleanToolResult = this.removeStructureHints(block.output);
-				const toolResultData = {
-					toolName: block.toolName,
-					toolInput,
-					toolResult: cleanToolResult,
-					compressedAt: (/* @__PURE__ */ new Date()).toISOString()
-				};
-				if (this.isEmpty(toolResultData)) {
-					logger.debug({
-						toolName: block.toolName,
-						toolCallId: block.toolCallId
-					}, "Skipping empty tool result");
-					continue;
-				}
-				const artifactData = {
-					artifactId,
-					taskId: `task_${this.conversationId}-${this.sessionId}`,
-					toolCallId: block.toolCallId,
-					artifactType: "tool_result",
-					pendingGeneration: true,
-					tenantId: this.tenantId,
-					projectId: this.projectId,
-					contextId: this.conversationId,
-					subAgentId: this.sessionId,
-					metadata: {
-						toolCallId: block.toolCallId,
-						toolName: block.toolName,
-						compressionReason: "mid_generation_context_limit"
-					},
-					summaryData: {
-						toolName: block.toolName,
-						note: "Compressed tool result - see full data for details"
-					},
-					data: toolResultData
-				};
-				const fullData = artifactData.data;
-				if (!(fullData && typeof fullData === "object" && Object.keys(fullData).length > 0 && fullData.toolResult && (typeof fullData.toolResult !== "object" || Object.keys(fullData.toolResult).length > 0))) {
-					logger.debug({
-						artifactId,
-						toolName: block.toolName,
-						toolCallId: block.toolCallId
-					}, "Skipping empty compression artifact");
-					continue;
-				}
-				session.recordEvent("artifact_saved", this.sessionId, artifactData);
-				this.processedToolCalls.add(block.toolCallId);
-				toolCallToArtifactMap[block.toolCallId] = artifactId;
-			}
-		}
-		this.lastProcessedMessageIndex = messages.length;
-		logger.debug({
-			totalArtifactsCreated: Object.keys(toolCallToArtifactMap).length,
-			newMessageIndex: this.lastProcessedMessageIndex
-		}, "Compression artifact processing completed");
-		return toolCallToArtifactMap;
-	}
-	/**
-	* 3. Create conversation summary with artifact references
-	*/
-	async createConversationSummary(messages, toolCallToArtifactMap) {
-		const textMessages = this.extractTextMessages(messages, toolCallToArtifactMap);
-		logger.debug({
-			sessionId: this.sessionId,
-			messageCount: messages.length,
-			textMessageCount: textMessages.length,
-			artifactCount: Object.keys(toolCallToArtifactMap).length,
-			sampleMessages: messages.slice(0, 2).map((m) => ({
-				role: m.role,
-				contentType: typeof m.content,
-				contentPreview: typeof m.content === "string" ? m.content.substring(0, 100) : "array/object"
-			}))
-		}, "Starting distillation with debug info");
-		const summary = await distillConversation({
-			messages,
-			conversationId: this.conversationId,
-			currentSummary: this.cumulativeSummary,
-			summarizerModel: this.summarizerModel,
-			toolCallToArtifactMap
-		});
-		this.cumulativeSummary = summary;
-		logger.debug({
-			sessionId: this.sessionId,
-			summaryGenerated: !!summary,
-			summaryHighLevel: summary?.high_level,
-			artifactsCount: summary?.related_artifacts?.length || 0
-		}, "Distillation completed");
-		return {
-			text_messages: textMessages,
-			summary
-		};
-	}
-	/**
-	* Extract text messages and convert tool calls to descriptive text
-	* Avoids API tool-call/tool-result pairing issues while preserving context
-	*/
-	extractTextMessages(messages, toolCallToArtifactMap) {
-		const textMessages = [];
-		const toolCallPairs = /* @__PURE__ */ new Map();
-		for (const message of messages) if (Array.isArray(message.content)) {
-			for (const block of message.content) if (block.type === "tool-call") if (!toolCallPairs.has(block.toolCallId)) toolCallPairs.set(block.toolCallId, {
-				call: block,
-				result: null
-			});
-			else toolCallPairs.get(block.toolCallId).call = block;
-			else if (block.type === "tool-result") if (!toolCallPairs.has(block.toolCallId)) toolCallPairs.set(block.toolCallId, {
-				call: null,
-				result: block
-			});
-			else toolCallPairs.get(block.toolCallId).result = block;
-		}
-		for (const message of messages) if (message.role === "assistant" && typeof message.content === "string") textMessages.push({
-			role: message.role,
-			content: message.content
-		});
-		else if (message.role === "assistant" && Array.isArray(message.content)) {
-			const textParts = [];
-			const toolCallsInMessage = /* @__PURE__ */ new Set();
-			const preservedBlocks = [];
-			for (const block of message.content) if (block.type === "text") textParts.push(block.text);
-			else if (block.type === "tool-call" && block.toolName === "thinking_complete") {} else if (block.type === "tool-call") toolCallsInMessage.add(block.toolCallId);
-			for (const toolCallId of toolCallsInMessage) {
-				const pair = toolCallPairs.get(toolCallId);
-				const artifactId = toolCallToArtifactMap[toolCallId];
-				if (pair?.call) {
-					const args = JSON.stringify(pair.call.input);
-					const artifactText = artifactId ? ` Results compressed into artifact: ${artifactId}.` : " Results were compressed but not saved.";
-					textParts.push(`I called ${pair.call.toolName}(${args}).${artifactText}`);
-				}
-			}
-			if (preservedBlocks.length > 0 && textParts.length > 0) {
-				const content = [...preservedBlocks];
-				if (textParts.length > 0) content.push({
-					type: "text",
-					text: textParts.join("\n\n")
-				});
-				textMessages.push({
-					role: message.role,
-					content
-				});
-			} else if (preservedBlocks.length > 0) textMessages.push({
-				role: message.role,
-				content: preservedBlocks
-			});
-			else if (textParts.length > 0) textMessages.push({
-				role: message.role,
-				content: textParts.join("\n\n")
-			});
-		}
-		return textMessages;
-	}
-	/**
-	* Check if tool result data is effectively empty
-	*/
-	isEmpty(toolResultData) {
-		if (!toolResultData || typeof toolResultData !== "object") return true;
-		const { toolResult } = toolResultData;
-		if (!toolResult) return true;
-		if (typeof toolResult === "object" && !Array.isArray(toolResult)) {
-			const keys = Object.keys(toolResult);
-			if (keys.length === 0) return true;
-			return keys.every((key) => {
-				const value = toolResult[key];
-				if (value === null || value === void 0 || value === "") return true;
-				if (Array.isArray(value) && value.length === 0) return true;
-				if (typeof value === "object" && Object.keys(value).length === 0) return true;
-				return false;
-			});
-		}
-		if (Array.isArray(toolResult) && toolResult.length === 0) return true;
-		if (typeof toolResult === "string" && toolResult.trim() === "") return true;
-		return false;
-	}
-	/**
-	* Recursively remove _structureHints from an object
-	*/
-	removeStructureHints(obj) {
-		if (obj === null || obj === void 0) return obj;
-		if (Array.isArray(obj)) return obj.map((item) => this.removeStructureHints(item));
-		if (typeof obj === "object") {
-			const cleaned = {};
-			for (const [key, value] of Object.entries(obj)) if (key !== "_structureHints") cleaned[key] = this.removeStructureHints(value);
-			return cleaned;
-		}
-		return obj;
-	}
-	/**
 	* Get current state for debugging
 	*/
 	getState() {
 		return {
+			...super.getState(),
 			shouldCompress: this.shouldCompress,
-			config: this.config
+			lastProcessedMessageIndex: this.lastProcessedMessageIndex
 		};
 	}
-	/**
-	* Get the current compression summary
-	*/
-	getCompressionSummary() {
-		return this.cumulativeSummary;
-	}
 };
 
 //#endregion
-export { MidGenerationCompressor, getCompressionConfigFromEnv };
+export { MidGenerationCompressor };