agent-relay 1.3.1 → 1.3.3

package/dist/health-worker.js

@@ -0,0 +1,79 @@
+/**
+ * Health Check Worker Thread
+ *
+ * Runs a minimal HTTP server on a separate thread to handle health checks.
+ * This ensures health checks respond even when the main event loop is blocked
+ * by heavy compute tasks (builds, large file operations, etc.).
+ */
+import { parentPort, workerData } from 'node:worker_threads';
+import http from 'node:http';
+// Default stats until we receive updates from main thread
+let currentStats = {
+    uptime: 0,
+    memoryMB: 0,
+    relayConnected: false,
+    agentCount: 0,
+    status: 'healthy',
+};
+// Track when we last received stats from main thread
+let lastStatsUpdate = Date.now();
+const STATS_STALE_THRESHOLD_MS = 60_000; // 1 minute
+// Listen for stats updates from main thread
+if (parentPort) {
+    parentPort.on('message', (stats) => {
+        currentStats = stats;
+        lastStatsUpdate = Date.now();
+    });
+}
+const { port } = workerData;
+const server = http.createServer((req, res) => {
+    // Only handle /health endpoint
+    if (req.url !== '/health' && req.url !== '/') {
+        res.writeHead(404, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: 'Not found' }));
+        return;
+    }
+    // Check if stats are stale (main thread might be blocked)
+    const statsAge = Date.now() - lastStatsUpdate;
+    const isStale = statsAge > STATS_STALE_THRESHOLD_MS;
+    // Determine status
+    let status = currentStats.status;
+    if (isStale) {
+        status = 'busy'; // Main thread is likely blocked
+    }
+    const response = {
+        status,
+        uptime: currentStats.uptime,
+        memoryMB: currentStats.memoryMB,
+        relayConnected: currentStats.relayConnected,
+        agentCount: currentStats.agentCount,
+        statsAgeMs: statsAge,
+        worker: true, // Indicates response is from worker thread
+    };
+    // Return 200 for healthy/busy, 503 for degraded
+    const statusCode = status === 'degraded' ? 503 : 200;
+    res.writeHead(statusCode, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify(response));
+});
+server.listen(port, '0.0.0.0', () => {
+    console.log(`[health-worker] Health check server listening on port ${port}`);
+    // Notify main thread we're ready
+    if (parentPort) {
+        parentPort.postMessage({ type: 'ready', port });
+    }
+});
+// Handle errors gracefully
+server.on('error', (err) => {
+    console.error('[health-worker] Server error:', err);
+    if (parentPort) {
+        parentPort.postMessage({ type: 'error', error: String(err) });
+    }
+});
+// Keep the worker alive
+process.on('uncaughtException', (err) => {
+    console.error('[health-worker] Uncaught exception:', err);
+});
+process.on('unhandledRejection', (err) => {
+    console.error('[health-worker] Unhandled rejection:', err);
+});
+//# sourceMappingURL=health-worker.js.map

package/dist/index.d.ts

@@ -8,5 +8,6 @@ export * from './wrapper/index.js';
 export * from './utils/index.js';
 export * from './hooks/index.js';
 export { type StoredMessage, type MessageQuery, type StorageAdapter, type StorageConfig, } from './storage/adapter.js';
-export { type MemoryAdapter, type MemoryEntry, type MemoryConfig, type MemoryService, type MemorySearchQuery, type AddMemoryOptions, type MemoryResult, createMemoryAdapter, createMemoryService, createMemoryHooks, getMemoryHooks, InMemoryAdapter, SupermemoryAdapter, } from './memory/index.js';
+export { type MemoryAdapter, type MemoryEntry, type MemoryConfig, type MemoryService, type MemorySearchQuery, type AddMemoryOptions, type MemoryResult, createMemoryAdapter, createMemoryService, createMemoryHooks, getMemoryHooks, InMemoryAdapter, SupermemoryAdapter, ContextCompactor, createContextCompactor, estimateTokens, estimateContextTokens, type CompactionConfig, type CompactionResult, } from './memory/index.js';
+export { type DLQStorageAdapter, type DeadLetter, type DLQConfig, type DLQStats, type DLQQuery, SQLiteDLQAdapter, PostgresDLQAdapter, InMemoryDLQAdapter, createDLQAdapter, DEFAULT_DLQ_CONFIG, } from './storage/dlq-adapter.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -8,5 +8,9 @@ export * from './wrapper/index.js';
 export * from './utils/index.js';
 export * from './hooks/index.js';
 // Memory types and adapters for external consumers
-export { createMemoryAdapter, createMemoryService, createMemoryHooks, getMemoryHooks, InMemoryAdapter, SupermemoryAdapter, } from './memory/index.js';
+export { createMemoryAdapter, createMemoryService, createMemoryHooks, getMemoryHooks, InMemoryAdapter, SupermemoryAdapter, 
+// Context compaction
+ContextCompactor, createContextCompactor, estimateTokens, estimateContextTokens, } from './memory/index.js';
+// Dead Letter Queue adapters
+export { SQLiteDLQAdapter, PostgresDLQAdapter, InMemoryDLQAdapter, createDLQAdapter, DEFAULT_DLQ_CONFIG, } from './storage/dlq-adapter.js';
 //# sourceMappingURL=index.js.map

package/dist/memory/context-compaction.d.ts

@@ -0,0 +1,156 @@
+/**
+ * Context Compaction for Long Agent Sessions
+ *
+ * Manages conversation context to prevent token limit exhaustion.
+ * Provides token counting, message summarization, and context pruning.
+ *
+ * Inspired by russian-code-ts context management targets:
+ * - Token estimation: <20ms
+ * - Embeddings-based semantic search for relevant context
+ *
+ * Strategies:
+ * 1. Fast token estimation (character-based heuristic)
+ * 2. Importance-weighted message retention
+ * 3. Sliding window with summary injection
+ * 4. Semantic deduplication of similar messages
+ */
+export interface Message {
+    id: string;
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: number;
+    /** Message importance (0-100, higher = more important) */
+    importance?: number;
+    /** Whether this is a summary message */
+    isSummary?: boolean;
+    /** Original message IDs if this is a summary */
+    summarizes?: string[];
+    /** Thread ID for grouping */
+    thread?: string;
+    /** Token count (cached) */
+    tokenCount?: number;
+}
+export interface ContextWindow {
+    messages: Message[];
+    totalTokens: number;
+    maxTokens: number;
+    usagePercent: number;
+}
+export interface CompactionResult {
+    /** Messages after compaction */
+    messages: Message[];
+    /** Number of messages removed */
+    messagesRemoved: number;
+    /** Tokens saved */
+    tokensSaved: number;
+    /** Summary message added (if any) */
+    summaryAdded?: Message;
+    /** Compaction strategy used */
+    strategy: CompactionStrategy;
+}
+export type CompactionStrategy = 'none' | 'trim_old' | 'trim_low_importance' | 'summarize' | 'deduplicate' | 'aggressive';
+export interface CompactionConfig {
+    /** Maximum tokens for context window */
+    maxTokens: number;
+    /** Target token usage after compaction (e.g., 0.7 = 70%) */
+    targetUsage: number;
+    /** Threshold to trigger compaction (e.g., 0.9 = 90%) */
+    compactionThreshold: number;
+    /** Minimum importance to retain during compaction */
+    minImportanceRetain: number;
+    /** Number of recent messages to always keep */
+    keepRecentCount: number;
+    /** Enable summarization */
+    enableSummarization: boolean;
+    /** Enable semantic deduplication */
+    enableDeduplication: boolean;
+    /** Similarity threshold for deduplication (0-1) */
+    deduplicationThreshold: number;
+}
+/**
+ * Fast token estimation using character-based heuristic.
+ * Targets <20ms latency for large texts.
+ *
+ * Heuristic: ~4 characters per token for English text.
+ * Adjusts for code (more tokens per char) and whitespace.
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Estimate tokens for a message (uses caching).
+ */
+export declare function estimateMessageTokens(message: Message): number;
+/**
+ * Estimate tokens for entire context.
+ */
+export declare function estimateContextTokens(messages: Message[]): number;
+/**
+ * Calculate importance score for a message.
+ * Higher scores = more important to retain.
+ */
+export declare function calculateImportance(message: Message, index: number, total: number): number;
+/**
+ * Simple similarity score between two strings (Jaccard on word set).
+ * Returns 0-1 where 1 = identical.
+ */
+export declare function calculateSimilarity(a: string, b: string): number;
+/**
+ * Find duplicate/similar messages.
+ */
+export declare function findDuplicates(messages: Message[], threshold?: number): Map<string, string[]>;
+/**
+ * Create a summary of multiple messages.
+ * This is a simple extractive summary - in production, use an LLM.
+ */
+export declare function createSummary(messages: Message[]): Message;
+/**
+ * Context compaction manager.
+ */
+export declare class ContextCompactor {
+    private config;
+    constructor(config?: Partial<CompactionConfig>);
+    /**
+     * Get current context window status.
+     */
+    getContextWindow(messages: Message[]): ContextWindow;
+    /**
+     * Check if compaction is needed.
+     */
+    needsCompaction(messages: Message[]): boolean;
+    /**
+     * Perform context compaction.
+     */
+    compact(messages: Message[]): CompactionResult;
+    /**
+     * Add a message to context with automatic compaction if needed.
+     */
+    addMessage(messages: Message[], newMessage: Message): {
+        messages: Message[];
+        compacted: boolean;
+        result?: CompactionResult;
+    };
+    /**
+     * Get token budget remaining.
+     */
+    getTokenBudget(messages: Message[]): {
+        used: number;
+        remaining: number;
+        percentUsed: number;
+    };
+}
+/**
+ * Create a context compactor with the given configuration.
+ */
+export declare function createContextCompactor(config?: Partial<CompactionConfig>): ContextCompactor;
+/**
+ * Format token count for display.
+ */
+export declare function formatTokenCount(tokens: number): string;
+/**
+ * Benchmark token estimation performance.
+ */
+export declare function benchmarkTokenEstimation(iterations?: number): {
+    avgNs: number;
+    maxNs: number;
+    tokensPerMs: number;
+};
+//# sourceMappingURL=context-compaction.d.ts.map