byterover-cli 2.0.0 → 2.1.0

package/dist/agent/infra/blob/file-blob-storage.js

@@ -0,0 +1,454 @@
+import { randomUUID } from 'node:crypto';
+import * as fs from 'node:fs/promises';
+import { join } from 'node:path';
+import { BlobError } from '../../core/domain/errors/blob-error.js';
+/**
+ * File-based blob storage implementation.
+ *
+ * Stores blobs as individual files on the filesystem:
+ *   {storageDir}/blobs/{key}/content.bin  — binary content
+ *   {storageDir}/blobs/{key}/metadata.json — JSON metadata
+ *
+ * Features:
+ * - One directory per blob (O(1) read/write/delete)
+ * - Atomic writes via write-to-temp + rename
+ * - Size limit enforcement (per-blob and total)
+ * - In-memory mode for fast unit tests
+ * - Prefix-based listing via readdir
+ */
+export class FileBlobStorage {
+    baseDir;
+    initialized = false;
+    inMemory;
+    maxBlobSize;
+    maxTotalSize;
+    memoryStore = null;
+    storageDir;
+    constructor(config) {
+        this.inMemory = config?.inMemory ?? false;
+        this.storageDir = config?.storageDir ?? '';
+        if (!this.inMemory && !this.storageDir) {
+            throw new Error('FileBlobStorage: storageDir is required when inMemory is false');
+        }
+        this.baseDir = join(this.storageDir, 'blobs');
+        this.maxBlobSize = config?.maxBlobSize ?? 100 * 1024 * 1024; // 100MB default
+        this.maxTotalSize = config?.maxTotalSize ?? 1024 * 1024 * 1024; // 1GB default
+    }
+    /**
+     * Clear all blobs from storage.
+     */
+    async clear() {
+        this.ensureInitialized();
+        try {
+            if (this.inMemory) {
+                this.memoryStore.clear();
+                return;
+            }
+            // Read all entries and remove each directory
+            let entries;
+            try {
+                entries = await fs.readdir(this.baseDir, { withFileTypes: true });
+            }
+            catch {
+                return; // Nothing to clear
+            }
+            for (const entry of entries) {
+                if (entry.isDirectory()) {
+                    const dirPath = join(this.baseDir, entry.name);
+                    // eslint-disable-next-line no-await-in-loop
+                    await fs.rm(dirPath, { force: true, recursive: true });
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof BlobError) {
+                throw error;
+            }
+            throw BlobError.deleteError(`Failed to clear storage: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Close the storage. Releases in-memory data.
+     */
+    close() {
+        if (this.inMemory) {
+            this.memoryStore = null;
+        }
+        this.initialized = false;
+    }
+    /**
+     * Delete a blob by its key.
+     */
+    async delete(key) {
+        this.ensureInitialized();
+        this.validateKey(key);
+        if (this.inMemory) {
+            if (!this.memoryStore.has(key)) {
+                throw BlobError.notFound(key);
+            }
+            this.memoryStore.delete(key);
+            return;
+        }
+        const blobDir = join(this.baseDir, key);
+        try {
+            await fs.access(blobDir);
+        }
+        catch {
+            throw BlobError.notFound(key);
+        }
+        try {
+            await fs.rm(blobDir, { force: true, recursive: true });
+        }
+        catch (error) {
+            throw BlobError.deleteError(`Failed to delete blob ${key}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Check if a blob exists.
+     */
+    async exists(key) {
+        this.ensureInitialized();
+        this.validateKey(key);
+        if (this.inMemory) {
+            return this.memoryStore.has(key);
+        }
+        try {
+            await fs.access(join(this.baseDir, key, 'metadata.json'));
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get metadata for a blob without retrieving its content.
+     */
+    async getMetadata(key) {
+        this.ensureInitialized();
+        this.validateKey(key);
+        try {
+            if (this.inMemory) {
+                const entry = this.memoryStore.get(key);
+                return entry ? this.toPublicMetadata(entry.metadata) : undefined;
+            }
+            return this.readMetadataFromDisk(key);
+        }
+        catch (error) {
+            if (error instanceof BlobError) {
+                throw error;
+            }
+            throw BlobError.retrievalError(`Failed to read metadata for blob ${key}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Get storage statistics.
+     */
+    async getStats() {
+        this.ensureInitialized();
+        try {
+            if (this.inMemory) {
+                let totalSize = 0;
+                for (const entry of this.memoryStore.values()) {
+                    totalSize += entry.metadata.size;
+                }
+                return {
+                    lastUpdated: Date.now(),
+                    totalBlobs: this.memoryStore.size,
+                    totalSize,
+                };
+            }
+            return this.getStatsFromDisk();
+        }
+        catch (error) {
+            if (error instanceof BlobError) {
+                throw error;
+            }
+            throw BlobError.retrievalError(`Failed to get storage stats: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Initialize the storage backend.
+     */
+    async initialize() {
+        if (this.initialized) {
+            return;
+        }
+        try {
+            if (this.inMemory) {
+                this.memoryStore = new Map();
+            }
+            else {
+                await fs.mkdir(this.baseDir, { recursive: true });
+            }
+            this.initialized = true;
+        }
+        catch (error) {
+            throw BlobError.initializationError(`Failed to initialize file blob storage: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * List all blob keys, optionally filtered by prefix.
+     */
+    async list(prefix) {
+        this.ensureInitialized();
+        try {
+            if (this.inMemory) {
+                let keys = [...this.memoryStore.keys()];
+                if (prefix) {
+                    keys = keys.filter((k) => k.startsWith(prefix));
+                }
+                keys.sort();
+                return keys;
+            }
+            return this.listFromDisk(prefix);
+        }
+        catch (error) {
+            if (error instanceof BlobError) {
+                throw error;
+            }
+            throw BlobError.retrievalError(`Failed to list blobs: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Retrieve a blob by its key.
+     */
+    async retrieve(key) {
+        this.ensureInitialized();
+        this.validateKey(key);
+        try {
+            if (this.inMemory) {
+                const entry = this.memoryStore.get(key);
+                if (!entry) {
+                    return undefined;
+                }
+                return {
+                    content: entry.content,
+                    key,
+                    metadata: this.toPublicMetadata(entry.metadata),
+                };
+            }
+            return this.retrieveFromDisk(key);
+        }
+        catch (error) {
+            if (error instanceof BlobError) {
+                throw error;
+            }
+            throw BlobError.retrievalError(`Failed to retrieve blob ${key}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    /**
+     * Store a blob with optional metadata.
+     */
+    async store(key, content, metadata) {
+        this.ensureInitialized();
+        this.validateKey(key);
+        const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content);
+        // Check individual blob size
+        if (buffer.length > this.maxBlobSize) {
+            throw BlobError.tooLarge(buffer.length, this.maxBlobSize);
+        }
+        // Check total storage size
+        const stats = await this.getStats();
+        const existing = await this.retrieve(key);
+        const existingSize = existing?.metadata.size ?? 0;
+        const newTotalSize = stats.totalSize - existingSize + buffer.length;
+        if (newTotalSize > this.maxTotalSize) {
+            throw BlobError.totalSizeExceeded(stats.totalSize - existingSize, buffer.length, this.maxTotalSize);
+        }
+        const now = Date.now();
+        const fullMetadata = {
+            createdAt: existing?.metadata.createdAt ?? now,
+            size: buffer.length,
+            updatedAt: now,
+            ...metadata,
+        };
+        const storedMeta = {
+            createdAt: fullMetadata.createdAt,
+            size: buffer.length,
+            updatedAt: fullMetadata.updatedAt,
+        };
+        if (fullMetadata.contentType) {
+            storedMeta.contentType = fullMetadata.contentType;
+        }
+        if (fullMetadata.originalName) {
+            storedMeta.originalName = fullMetadata.originalName;
+        }
+        if (fullMetadata.tags) {
+            storedMeta.tags = fullMetadata.tags;
+        }
+        try {
+            if (this.inMemory) {
+                this.memoryStore.set(key, { content: buffer, metadata: storedMeta });
+            }
+            else {
+                await this.writeToDisk(key, buffer, storedMeta);
+            }
+            return {
+                content: buffer,
+                key,
+                metadata: fullMetadata,
+            };
+        }
+        catch (error) {
+            if (error instanceof BlobError) {
+                throw error;
+            }
+            throw BlobError.storageError(`Failed to store blob ${key}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : undefined);
+        }
+    }
+    // ---------------------------------------------------------------------------
+    // Private helpers
+    // ---------------------------------------------------------------------------
+    ensureInitialized() {
+        if (!this.initialized) {
+            throw BlobError.notInitialized();
+        }
+    }
+    /**
+     * Get stats by scanning the blobs directory.
+     */
+    async getStatsFromDisk() {
+        let totalBlobs = 0;
+        let totalSize = 0;
+        let entries;
+        try {
+            entries = await fs.readdir(this.baseDir, { withFileTypes: true });
+        }
+        catch {
+            return { lastUpdated: Date.now(), totalBlobs: 0, totalSize: 0 };
+        }
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                try {
+                    const metaPath = join(this.baseDir, entry.name, 'metadata.json');
+                    // eslint-disable-next-line no-await-in-loop
+                    const metaContent = await fs.readFile(metaPath, 'utf8');
+                    const meta = JSON.parse(metaContent);
+                    totalBlobs++;
+                    totalSize += meta.size;
+                }
+                catch {
+                    // Skip corrupt entries
+                }
+            }
+        }
+        return { lastUpdated: Date.now(), totalBlobs, totalSize };
+    }
+    /**
+     * List keys from disk, optionally filtered by prefix.
+     */
+    async listFromDisk(prefix) {
+        let entries;
+        try {
+            entries = await fs.readdir(this.baseDir, { withFileTypes: true });
+        }
+        catch {
+            return [];
+        }
+        let keys = entries
+            .filter((e) => e.isDirectory())
+            .map((e) => e.name);
+        if (prefix) {
+            keys = keys.filter((k) => k.startsWith(prefix));
+        }
+        keys.sort();
+        return keys;
+    }
+    /**
+     * Read metadata from disk for a given key.
+     */
+    async readMetadataFromDisk(key) {
+        const metaPath = join(this.baseDir, key, 'metadata.json');
+        try {
+            const content = await fs.readFile(metaPath, 'utf8');
+            const stored = JSON.parse(content);
+            return this.toPublicMetadata(stored);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Retrieve a blob from disk.
+     */
+    async retrieveFromDisk(key) {
+        const blobDir = join(this.baseDir, key);
+        const contentPath = join(blobDir, 'content.bin');
+        const metaPath = join(blobDir, 'metadata.json');
+        try {
+            const [contentBuf, metaContent] = await Promise.all([
+                fs.readFile(contentPath),
+                fs.readFile(metaPath, 'utf8'),
+            ]);
+            const stored = JSON.parse(metaContent);
+            return {
+                content: contentBuf,
+                key,
+                metadata: this.toPublicMetadata(stored),
+            };
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return undefined;
+            }
+            throw error;
+        }
+    }
+    /**
+     * Convert StoredMetadata to public BlobMetadata.
+     */
+    toPublicMetadata(stored) {
+        const metadata = {
+            createdAt: stored.createdAt,
+            size: stored.size,
+            updatedAt: stored.updatedAt,
+        };
+        if (stored.contentType) {
+            metadata.contentType = stored.contentType;
+        }
+        if (stored.originalName) {
+            metadata.originalName = stored.originalName;
+        }
+        if (stored.tags) {
+            metadata.tags = stored.tags;
+        }
+        return metadata;
+    }
+    /**
+     * Validate blob key.
+     * Keys must be alphanumeric with hyphens and underscores only.
+     */
+    validateKey(key) {
+        if (!key || typeof key !== 'string') {
+            throw BlobError.invalidKey(String(key), 'Key must be a non-empty string');
+        }
+        if (key.length === 0) {
+            throw BlobError.invalidKey(key, 'Key cannot be empty');
+        }
+        const validKeyRegex = /^[a-zA-Z0-9_-]+$/;
+        if (!validKeyRegex.test(key)) {
+            throw BlobError.invalidKey(key, 'Key must contain only alphanumeric characters, hyphens, and underscores');
+        }
+    }
+    /**
+     * Write blob content and metadata to disk atomically.
+     */
+    async writeToDisk(key, content, metadata) {
+        const blobDir = join(this.baseDir, key);
+        await fs.mkdir(blobDir, { recursive: true });
+        const contentPath = join(blobDir, 'content.bin');
+        const metaPath = join(blobDir, 'metadata.json');
+        const tmpSuffix = `.tmp.${randomUUID()}`;
+        // Write content atomically
+        const tmpContentPath = `${contentPath}${tmpSuffix}`;
+        await fs.writeFile(tmpContentPath, content);
+        await fs.rename(tmpContentPath, contentPath);
+        // Write metadata atomically
+        const tmpMetaPath = `${metaPath}${tmpSuffix}`;
+        await fs.writeFile(tmpMetaPath, JSON.stringify(metadata, null, 2), 'utf8');
+        await fs.rename(tmpMetaPath, metaPath);
+    }
+}

package/dist/agent/infra/blob/index.d.ts

@@ -1,10 +1,9 @@
 /**
  * Blob storage module
- * Provides persistent storage for binary/large data blobs using SQLite
+ * Provides persistent storage for binary/large data blobs
  */
 export type { BlobMetadata, BlobStats, BlobStorageConfig, StoredBlob } from '../../core/domain/blob/types.js';
 export { BlobError, BlobErrorCode } from '../../core/domain/errors/blob-error.js';
 export type { IBlobStorage } from '../../core/interfaces/i-blob-storage.js';
 export { createBlobStorage } from './blob-storage-factory.js';
-export * as BlobMigrations from './migrations.js';
-export { SqliteBlobStorage } from './sqlite-blob-storage.js';
+export { FileBlobStorage } from './file-blob-storage.js';

package/dist/agent/infra/blob/index.js

@@ -1,12 +1,10 @@
 /**
  * Blob storage module
- * Provides persistent storage for binary/large data blobs using SQLite
+ * Provides persistent storage for binary/large data blobs
  */
 // Re-export errors from core
 export { BlobError, BlobErrorCode } from '../../core/domain/errors/blob-error.js';
-// Factory (always returns SQLite implementation)
+// Factory (returns file-based implementation)
 export { createBlobStorage } from './blob-storage-factory.js';
-// Migration system
-export * as BlobMigrations from './migrations.js';
-// SQLite storage implementation
-export { SqliteBlobStorage } from './sqlite-blob-storage.js';
+// File-based storage implementation
+export { FileBlobStorage } from './file-blob-storage.js';

package/dist/agent/infra/llm/agent-llm-service.d.ts

@@ -8,6 +8,7 @@ import type { MemoryManager } from '../memory/memory-manager.js';
 import type { SystemPromptManager } from '../system-prompt/system-prompt-manager.js';
 import type { ToolManager } from '../tools/tool-manager.js';
 import type { CompactionService } from './context/compaction/compaction-service.js';
+import type { ICompressionStrategy } from './context/compression/types.js';
 import { type IContentGenerator } from '../../core/interfaces/i-content-generator.js';
 import { SessionEventBus } from '../events/event-emitter.js';
 import { ContextManager, type FileData, type ImageData } from './context/context-manager.js';
@@ -122,6 +123,8 @@ export declare class AgentLLMService implements ILLMService {
      */
     constructor(sessionId: string, generator: IContentGenerator, config: AgentLLMServiceConfig, options: {
         compactionService?: CompactionService;
+        /** Optional compression strategies for context overflow management */
+        compressionStrategies?: ICompressionStrategy[];
         historyStorage?: IHistoryStorage;
         logger?: ILogger;
         memoryManager?: MemoryManager;

package/dist/agent/infra/llm/agent-llm-service.js

@@ -2,7 +2,7 @@ import { getErrorMessage } from '../../../server/utils/error-helpers.js';
 import { AgentStateMachine } from '../../core/domain/agent/agent-state-machine.js';
 import { AgentState, TerminationReason } from '../../core/domain/agent/agent-state.js';
 import { LlmGenerationError, LlmMaxIterationsError, LlmResponseParsingError } from '../../core/domain/errors/llm-error.js';
-import { getEffectiveMaxInputTokens, getMaxInputTokensForModel, getProviderFromModel, isValidProviderModel, safeParseLLMConfig, } from '../../core/domain/llm/index.js';
+import { getEffectiveMaxInputTokens, getMaxInputTokensForModel, isValidProviderModel, resolveRegistryProvider, safeParseLLMConfig, } from '../../core/domain/llm/index.js';
 import { StreamChunkType, } from '../../core/interfaces/i-content-generator.js';
 import { NoOpLogger } from '../../core/interfaces/i-logger.js';
 import { EnvironmentContextBuilder } from '../environment/environment-context-builder.js';
@@ -141,6 +141,7 @@ export class AgentLLMService {
         }
         // Initialize context manager with optional history storage
         this.contextManager = new ContextManager({
+            compressionStrategies: options.compressionStrategies,
             formatter: this.formatter,
             historyStorage: options.historyStorage,
             maxInputTokens: this.config.maxInputTokens,
@@ -558,33 +559,7 @@ export class AgentLLMService {
      * @returns Provider type ('claude', 'gemini', or 'openai')
      */
     detectProviderType(model, explicitProvider) {
-        // 1. Explicit provider mapping takes priority
-        if (explicitProvider) {
-            if (explicitProvider === 'anthropic')
-                return 'claude';
-            if (explicitProvider === 'google' || explicitProvider === 'google-vertex')
-                return 'gemini';
-            if (['groq', 'mistral', 'openai', 'openai-compatible', 'openrouter', 'xai'].includes(explicitProvider))
-                return 'openai';
-        }
-        // 2. Use registry to detect provider from model name
-        const registryProvider = getProviderFromModel(model);
-        if (registryProvider === 'claude')
-            return 'claude';
-        if (registryProvider === 'gemini')
-            return 'gemini';
-        if (registryProvider === 'openai')
-            return 'openai';
-        // 3. Fallback to string prefix matching for unknown models
-        const lowerModel = model.toLowerCase();
-        if (lowerModel.startsWith('claude'))
-            return 'claude';
-        if (lowerModel.startsWith('gpt') ||
-            lowerModel.startsWith('o1') ||
-            lowerModel.startsWith('o3') ||
-            lowerModel.startsWith('o4'))
-            return 'openai';
-        return 'gemini';
+        return resolveRegistryProvider(model, explicitProvider);
     }
     /**
      * Determine which reflection prompt to add based on hierarchical priority.
@@ -728,31 +703,38 @@ export class AgentLLMService {
             const maxMessageTokens = this.config.maxInputTokens - systemPromptTokens;
             // Target utilization to leave headroom for response
             const targetMessageTokens = Math.floor(maxMessageTokens * TARGET_MESSAGE_TOKEN_UTILIZATION);
-            // Smart pruning: try clearing old tool outputs before destructive compression
-            this.contextManager.markToolOutputsCompacted(2);
-            // Get token counts (recalculate if pruning changed content)
+            // Count current token usage
             const currentMessages = this.contextManager.getMessages();
-            const effectiveTokenCounts = currentMessages.map((msg) => this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)));
-            // Destructive compression as fallback if still over limit
-            this.contextManager.compressMessage(targetMessageTokens, effectiveTokenCounts);
-            // Emergency guard: if still over 90% after normal compression, force aggressive compaction
-            // This is critical for curate/query commands where there's only 1 user turn,
-            // making the protectedTurns=2 in markToolOutputsCompacted() ineffective.
-            if (executionContext?.commandType === 'curate' || executionContext?.commandType === 'query') {
-                const postCompressionMessages = this.contextManager.getMessages();
-                const postCompressionTokens = postCompressionMessages.reduce((sum, msg) => sum + this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)), 0);
-                const totalWithSystem = postCompressionTokens + systemPromptTokens;
-                if (totalWithSystem > this.config.maxInputTokens * 0.9) {
-                    // Aggressive: compact ALL tool outputs (protect 0 turns instead of 2)
-                    this.contextManager.markToolOutputsCompacted(0);
-                    // Recalculate and re-compress
-                    const aggressiveMessages = this.contextManager.getMessages();
-                    const aggressiveTokens = aggressiveMessages.map((msg) => this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)));
-                    this.contextManager.compressMessage(targetMessageTokens, aggressiveTokens);
-                    this.sessionEventBus.emit('llmservice:warning', {
-                        message: `Emergency context compression triggered (${Math.round((totalWithSystem / this.config.maxInputTokens) * 100)}% utilization)`,
-                        taskId,
-                    });
+            const currentTokens = currentMessages.reduce((sum, msg) => sum + this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)), 0);
+            // Zero-cost continuity: skip all compression work if under threshold.
+            // Below 70% utilization, the agent pays zero overhead for context management.
+            if (currentTokens > targetMessageTokens) {
+                // Step 1: Non-destructive pruning — clear old tool outputs first
+                this.contextManager.markToolOutputsCompacted(2);
+                // Step 2: Recount after pruning
+                const afterPruningMessages = this.contextManager.getMessages();
+                const afterPruningTokens = afterPruningMessages.reduce((sum, msg) => sum + this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)), 0);
+                // Step 3: If still over, run escalated compression (L1→L2→L3) via strategy chain
+                if (afterPruningTokens > targetMessageTokens) {
+                    await this.contextManager.compressAndReplace(systemPromptTokens, targetMessageTokens);
+                }
+                // Step 4: Emergency guard for curate/query commands.
+                // Critical because curate/query have only 1 user turn, making
+                // protectedTurns=2 in markToolOutputsCompacted() ineffective.
+                if (executionContext?.commandType === 'curate' || executionContext?.commandType === 'query') {
+                    const postCompressionMessages = this.contextManager.getMessages();
+                    const postCompressionTokens = postCompressionMessages.reduce((sum, msg) => sum + this.generator.estimateTokensSync(typeof msg.content === 'string' ? msg.content : JSON.stringify(msg.content)), 0);
+                    const totalWithSystem = postCompressionTokens + systemPromptTokens;
+                    if (totalWithSystem > this.config.maxInputTokens * 0.9) {
+                        // Aggressive: compact ALL tool outputs (protect 0 turns instead of 2)
+                        this.contextManager.markToolOutputsCompacted(0);
+                        // Re-run escalated compression with aggressively pruned context
+                        await this.contextManager.compressAndReplace(systemPromptTokens, targetMessageTokens);
+                        this.sessionEventBus.emit('llmservice:warning', {
+                            message: `Emergency context compression triggered (${Math.round((totalWithSystem / this.config.maxInputTokens) * 100)}% utilization)`,
+                            taskId,
+                        });
+                    }
                 }
             }
             // Build generation request

package/dist/agent/infra/llm/context/compression/compression-helpers.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Shared compression helper functions.
+ *
+ * Extracted from ReactiveOverflowStrategy to enable reuse
+ * by EscalatedCompressionStrategy and other compression implementations.
+ */
+import type { ITokenizer } from '../../../../core/interfaces/i-tokenizer.js';
+import type { InternalMessage } from '../../../../core/interfaces/message-types.js';
+/**
+ * Count tokens in message history.
+ */
+export declare function countHistoryTokens(history: InternalMessage[], tokenizer: ITokenizer): number;
+/**
+ * Count tokens in a single message.
+ */
+export declare function countMessageTokens(message: InternalMessage, tokenizer: ITokenizer): number;
+/**
+ * Extract text content from a message.
+ */
+export declare function extractTextContent(message: InternalMessage): string;
+/**
+ * Find turn boundaries in message history.
+ *
+ * A turn boundary is the index where a user message starts.
+ * Returns indices of all user messages.
+ */
+export declare function findTurnBoundaries(messages: InternalMessage[]): number[];
+/**
+ * Format messages for the summary prompt.
+ */
+export declare function formatMessagesForSummary(messages: InternalMessage[]): string;
+/**
+ * Format role for display.
+ */
+export declare function formatRole(role: string): string;