@nexus-cortex/core 4.26.0

package/dist/middleware/RetryMiddleware.js

@@ -0,0 +1,268 @@
+/**
+ * Retry Middleware
+ *
+ * Provides retry orchestration with exponential backoff and jitter for failed operations.
+ * Uses error classification from ErrorClassificationMiddleware to determine retry eligibility.
+ *
+ * This component is standalone and can be used independently of the orchestrator.
+ *
+ * @version 1.0.0
+ * @author Agent 5 - Parallel Refactor Wave 1
+ */
+/**
+ * Default retry options
+ *
+ * These defaults provide a reasonable balance between resilience and performance:
+ * - 3 retries allows for transient network hiccups without excessive delays
+ * - 1 second base delay is short enough for quick recovery
+ * - 30 second max delay prevents indefinite waiting
+ * - 2x backoff multiplier follows industry standard exponential backoff
+ * - 10% jitter prevents thundering herd problem
+ */
+const DEFAULT_OPTIONS = {
+    maxRetries: 3,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    backoffMultiplier: 2,
+    jitterFactor: 0.1,
+};
+/**
+ * RetryMiddleware
+ *
+ * Orchestrates retry logic for failed operations using exponential backoff with jitter.
+ * Works in conjunction with ErrorClassificationMiddleware to determine which errors
+ * are retryable.
+ *
+ * **Exponential Backoff Algorithm:**
+ * ```
+ * delay = baseDelay * (backoffMultiplier ^ attempt)
+ * delay = min(delay, maxDelayMs)
+ * delay = delay ± (delay * jitterFactor * random())
+ * ```
+ *
+ * **Example backoff sequence (default options):**
+ * - Attempt 1: 1000ms ± 100ms = 900-1100ms
+ * - Attempt 2: 2000ms ± 200ms = 1800-2200ms
+ * - Attempt 3: 4000ms ± 400ms = 3600-4400ms
+ * - Attempt 4: 8000ms ± 800ms = 7200-8800ms
+ * - Capped at: 30000ms ± 3000ms = 27000-33000ms
+ *
+ * @example
+ * ```typescript
+ * const errorClassifier = new ErrorClassificationMiddleware();
+ * const retryMiddleware = new RetryMiddleware(errorClassifier, {
+ *   maxRetries: 3,
+ *   baseDelayMs: 1000,
+ *   maxDelayMs: 30000,
+ *   backoffMultiplier: 2,
+ *   jitterFactor: 0.1
+ * });
+ *
+ * const result = await retryMiddleware.executeWithRetry(
+ *   async () => {
+ *     return await fetchDataFromAPI();
+ *   },
+ *   'fetchDataFromAPI'
+ * );
+ *
+ * console.log(`Success after ${result.attemptCount} attempts`);
+ * console.log(`Total delay: ${result.totalDelayMs}ms`);
+ * ```
+ */
+export class RetryMiddleware {
+    errorClassifier;
+    options;
+    /**
+     * Create a new RetryMiddleware instance
+     *
+     * @param errorClassifier - Error classifier for determining retry eligibility
+     * @param options - Retry configuration options (merged with defaults)
+     */
+    constructor(errorClassifier, options = {}) {
+        this.errorClassifier = errorClassifier;
+        // Merge provided options with defaults
+        this.options = {
+            ...DEFAULT_OPTIONS,
+            ...options,
+        };
+        // Validate options
+        if (this.options.maxRetries < 0) {
+            throw new Error('maxRetries must be non-negative');
+        }
+        if (this.options.baseDelayMs < 0) {
+            throw new Error('baseDelayMs must be non-negative');
+        }
+        if (this.options.maxDelayMs < this.options.baseDelayMs) {
+            throw new Error('maxDelayMs must be greater than or equal to baseDelayMs');
+        }
+        if (this.options.backoffMultiplier < 1) {
+            throw new Error('backoffMultiplier must be at least 1');
+        }
+        if (this.options.jitterFactor < 0 || this.options.jitterFactor > 1) {
+            throw new Error('jitterFactor must be between 0 and 1');
+        }
+    }
+    /**
+     * Execute an operation with retry logic
+     *
+     * This method will:
+     * 1. Attempt the operation
+     * 2. If it fails, classify the error
+     * 3. If the error is retryable, wait with exponential backoff
+     * 4. Retry up to maxRetries times
+     * 5. If all retries fail, throw the last error with accumulated metadata
+     *
+     * @param operation - The async operation to execute
+     * @param context - Context string for logging/debugging (e.g., "fetchUserData", "executeToolX")
+     * @returns RetryResult containing the successful result and retry metadata
+     * @throws The last error if all retry attempts are exhausted or if a non-retryable error occurs
+     *
+     * @example
+     * ```typescript
+     * // Successful on first attempt
+     * const result = await retry.executeWithRetry(
+     *   async () => ({ data: 'success' }),
+     *   'testOperation'
+     * );
+     * // result.attemptCount === 1
+     * // result.totalDelayMs === 0
+     * // result.errors.length === 0
+     *
+     * // Retries on transient error
+     * let attempts = 0;
+     * const result = await retry.executeWithRetry(
+     *   async () => {
+     *     if (attempts++ < 2) throw new Error('ECONNRESET');
+     *     return { data: 'success' };
+     *   },
+     *   'retryOperation'
+     * );
+     * // result.attemptCount === 3
+     * // result.errors.length === 2
+     * ```
+     */
+    async executeWithRetry(operation, context) {
+        const errors = [];
+        let totalDelayMs = 0;
+        for (let attempt = 0; attempt <= this.options.maxRetries; attempt++) {
+            try {
+                // Attempt the operation
+                const result = await operation();
+                // Success! Return result with metadata
+                return {
+                    result,
+                    attemptCount: attempt + 1,
+                    totalDelayMs,
+                    errors,
+                };
+            }
+            catch (error) {
+                // Classify the error
+                const classification = this.errorClassifier.classify(error);
+                errors.push(classification);
+                // Check if we should retry
+                const isLastAttempt = attempt === this.options.maxRetries;
+                const shouldRetry = classification.isRetryable && !isLastAttempt;
+                if (!shouldRetry) {
+                    // Either non-retryable or exhausted retries - throw error
+                    const enhancedError = this.enhanceError(error, context, attempt + 1, totalDelayMs, errors);
+                    throw enhancedError;
+                }
+                // Calculate delay with exponential backoff and jitter
+                const delayMs = this.calculateDelay(attempt);
+                totalDelayMs += delayMs;
+                // Wait before retrying
+                await this.sleep(delayMs);
+            }
+        }
+        // This should never be reached due to the throw in the loop,
+        // but TypeScript needs this for type safety
+        throw new Error(`Retry loop completed unexpectedly for context: ${context}`);
+    }
+    /**
+     * Calculate delay for a given attempt number using exponential backoff with jitter
+     *
+     * The algorithm:
+     * 1. Calculate exponential delay: baseDelay * (multiplier ^ attempt)
+     * 2. Cap at maxDelayMs
+     * 3. Add random jitter: ± (delay * jitterFactor)
+     *
+     * **Jitter Purpose:**
+     * Jitter prevents the "thundering herd" problem where many clients retry
+     * simultaneously, potentially overwhelming a recovering service.
+     *
+     * @param attempt - The attempt number (0-indexed)
+     * @returns Delay in milliseconds (always non-negative)
+     *
+     * @example
+     * ```typescript
+     * // With default options (baseDelayMs=1000, backoffMultiplier=2, jitterFactor=0.1)
+     * retry.calculateDelay(0); // ~1000ms ± 10% = 900-1100ms
+     * retry.calculateDelay(1); // ~2000ms ± 10% = 1800-2200ms
+     * retry.calculateDelay(2); // ~4000ms ± 10% = 3600-4400ms
+     * retry.calculateDelay(10); // capped at maxDelayMs (30000ms) ± 10%
+     * ```
+     */
+    calculateDelay(attempt) {
+        // Calculate exponential delay
+        const exponentialDelay = this.options.baseDelayMs * Math.pow(this.options.backoffMultiplier, attempt);
+        // Cap at maximum delay
+        const cappedDelay = Math.min(exponentialDelay, this.options.maxDelayMs);
+        // Add jitter: random value between -jitterRange and +jitterRange
+        const jitterRange = cappedDelay * this.options.jitterFactor;
+        const jitter = (Math.random() * 2 - 1) * jitterRange; // -jitterRange to +jitterRange
+        // Ensure non-negative delay
+        const finalDelay = Math.max(0, cappedDelay + jitter);
+        return Math.round(finalDelay); // Round to whole milliseconds
+    }
+    /**
+     * Sleep for the specified duration
+     *
+     * @param ms - Milliseconds to sleep
+     * @returns Promise that resolves after the delay
+     */
+    sleep(ms) {
+        return new Promise(resolve => setTimeout(resolve, ms));
+    }
+    /**
+     * Enhance an error with retry metadata
+     *
+     * This adds useful debugging information to the error object without
+     * modifying the original error message or stack trace.
+     *
+     * @param error - The original error
+     * @param context - Context string
+     * @param attemptCount - Number of attempts made
+     * @param totalDelayMs - Total time spent waiting
+     * @param errors - Array of all error classifications
+     * @returns Enhanced error object
+     */
+    enhanceError(error, context, attemptCount, totalDelayMs, errors) {
+        // Create a new error object to avoid mutating the original
+        const enhanced = error instanceof Error ? error : new Error(String(error));
+        // Add retry metadata as a property (non-enumerable to avoid pollution)
+        Object.defineProperty(enhanced, 'retryMetadata', {
+            value: {
+                context,
+                attemptCount,
+                totalDelayMs,
+                errors,
+                lastErrorType: errors[errors.length - 1]?.errorType,
+                wasRetryable: errors[errors.length - 1]?.isRetryable,
+            },
+            enumerable: false,
+            writable: false,
+            configurable: true,
+        });
+        return enhanced;
+    }
+    /**
+     * Get the current retry options
+     *
+     * @returns Current retry options (readonly)
+     */
+    getOptions() {
+        return { ...this.options };
+    }
+}
+//# sourceMappingURL=RetryMiddleware.js.map

package/dist/middleware/RetryMiddleware.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"RetryMiddleware.js","sourceRoot":"","sources":["../../src/middleware/RetryMiddleware.ts"],"names":[],"mappings":"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"}

package/dist/middleware/SystemMessageMiddleware.d.ts

@@ -0,0 +1,165 @@
+/**
+ * System Message Injection Middleware
+ *
+ * Implements deterministic system message injection into user message content arrays.
+ * Extracted from CortexOrchestrator for modular architecture.
+ *
+ * Key Responsibilities:
+ * - Build injection context from session state
+ * - Generate template variables for dynamic content
+ * - Inject system messages at appropriate positions
+ * - Handle <system-reminder> tag wrapping
+ * - Sort and prioritize messages
+ *
+ * Based on Claude CLI injection patterns:
+ * - Inject INTO user message content (not as separate system messages)
+ * - Wrap in <system-reminder> tags for deterministic formatting
+ * - Support prepend and append positions
+ * - Priority-based ordering within each position
+ *
+ * @version 1.0.0
+ * @since Phase 3: Middleware Extraction
+ */
+import type { ModelConfig } from '../models/ModelConfig.interface.js';
+import type { SystemMessageLoader } from '../system-messages/SystemMessageLoader.js';
+import type { SystemReminderInjector } from '../system-messages/SystemReminderInjector.js';
+import type { ISystemMessageInjector, InjectionContext, TemplateVariables, MiddlewareContext } from './contracts/MiddlewareContracts.js';
+/**
+ * System Message Injection Middleware
+ *
+ * Handles injection of system messages into user message content arrays
+ * based on session phase, model capabilities, and tool presence.
+ *
+ * @example
+ * ```typescript
+ * const middleware = new SystemMessageMiddleware(
+ *   systemMessageLoader,
+ *   systemReminderInjector
+ * );
+ *
+ * const context = middleware.buildInjectionContext(model, hasTools, sessionContext);
+ * const templateVars = middleware.buildTemplateVariables(toolCount, sessionContext);
+ * const injectedContent = await middleware.injectSystemMessages(
+ *   userContent,
+ *   model,
+ *   hasTools,
+ *   sessionContext
+ * );
+ * ```
+ */
+export declare class SystemMessageMiddleware implements ISystemMessageInjector {
+    private readonly systemMessageLoader;
+    private readonly systemReminderInjector;
+    /**
+     * Create new system message middleware
+     *
+     * @param systemMessageLoader - Service for loading system messages from registry
+     * @param systemReminderInjector - Service for creating system reminders
+     */
+    constructor(systemMessageLoader: SystemMessageLoader, systemReminderInjector: SystemReminderInjector);
+    /**
+     * Build injection context from current session state
+     *
+     * Determines:
+     * - Session phase (start, ongoing, end) based on turn number
+     * - Model capabilities (reasoning, vision, tools, streaming)
+     * - Tool presence and count
+     * - API pattern for provider-specific behavior
+     *
+     * @param model - Model configuration
+     * @param hasTools - Whether tools are present in the request
+     * @param context - Middleware context with session information
+     * @returns Injection context for message filtering
+     *
+     * @example
+     * ```typescript
+     * const context = middleware.buildInjectionContext(
+     *   modelConfig,
+     *   true, // has tools
+     *   { sessionId: 'abc', conversationId: '123', turnNumber: 0, modelId: 'claude-3-5-sonnet', config }
+     * );
+     * // context.sessionPhase === 'start'
+     * // context.modelCapabilities === ['tools', 'streaming']
+     * ```
+     */
+    buildInjectionContext(model: ModelConfig, hasTools: boolean, context: MiddlewareContext): InjectionContext;
+    /**
+     * Build template variables for dynamic system message content
+     *
+     * Creates a map of variables that can be substituted into system messages
+     * using {{variable}} syntax.
+     *
+     * Available variables:
+     * - projectPath: Current project/workspace path
+     * - workspacePath: Alias for projectPath
+     * - currentDate: ISO date string (YYYY-MM-DD)
+     * - currentTime: Full ISO timestamp
+     * - toolCount: Number of available tools
+     * - toolNames: Array of tool names
+     * - sandboxEnabled: Whether sandbox execution is enabled
+     *
+     * @param toolCount - Number of available tools
+     * @param context - Middleware context with configuration
+     * @returns Template variables for substitution
+     *
+     * @example
+     * ```typescript
+     * const vars = middleware.buildTemplateVariables(15, context);
+     * // vars.toolCount === 15
+     * // vars.currentDate === '2025-11-12'
+     * // vars.toolNames === ['Read', 'Write', 'Edit', ...]
+     * ```
+     */
+    buildTemplateVariables(toolCount: number, context: MiddlewareContext): TemplateVariables;
+    /**
+     * Inject system messages into user message content array
+     *
+     * Implements the Claude CLI injection pattern:
+     * 1. Load applicable system messages from registry
+     * 2. Separate by position (prepend vs append)
+     * 3. Sort by priority within each position
+     * 4. Wrap in <system-reminder> tags if configured
+     * 5. Build final content array: [prepend] + [user content] + [append]
+     *
+     * @param userContent - User message content (string or array)
+     * @param model - Model configuration
+     * @param hasTools - Whether tools are present
+     * @param context - Middleware context
+     * @returns Modified content array with system messages injected
+     *
+     * @example
+     * ```typescript
+     * const injected = await middleware.injectSystemMessages(
+     *   "Hello, Claude!",
+     *   modelConfig,
+     *   true,
+     *   context
+     * );
+     * // Result: [
+     * //   { type: 'text', text: '<system-reminder>...prepend message...</system-reminder>' },
+     * //   { type: 'text', text: 'Hello, Claude!' },
+     * //   { type: 'text', text: '<system-reminder>...append message...</system-reminder>' }
+     * // ]
+     * ```
+     */
+    /**
+     * R28: cache-stable variant of {@link injectSystemMessages}.
+     *
+     * `prepend` system messages are the static base prompt (CORTEX.md /
+     * instructions / tool guidance). Returning them inside the user-message
+     * content makes them ride the *moving* latest-user-message slot, so the
+     * provider prompt-cache prefix is never byte-stable across tool-loop
+     * iterations (xAI observed flat cacheRead=128 / ~0.5%). This variant
+     * routes prepend content into a stable `systemPrompt` string (→ the
+     * provider `system` field, where anthropic/xai/openai cache the prefix)
+     * and keeps only `[user] + [append]` in `userContent`. Text is
+     * byte-preserved (incl. any `<system-reminder>` wrap) — only relocated,
+     * not rewritten — to minimize behavior change.
+     */
+    injectWithSystemSplit(userContent: string | any[], model: ModelConfig, hasTools: boolean, context: MiddlewareContext): Promise<{
+        systemPrompt: string | undefined;
+        userContent: any[];
+    }>;
+    injectSystemMessages(userContent: string | any[], model: ModelConfig, hasTools: boolean, context: MiddlewareContext): Promise<any[]>;
+}
+//# sourceMappingURL=SystemMessageMiddleware.d.ts.map

package/dist/middleware/SystemMessageMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SystemMessageMiddleware.d.ts","sourceRoot":"","sources":["../../src/middleware/SystemMessageMiddleware.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,oCAAoC,CAAC;AACtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,2CAA2C,CAAC;AACrF,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,8CAA8C,CAAC;AAC3F,OAAO,KAAK,EACV,sBAAsB,EACtB,gBAAgB,EAChB,iBAAiB,EACjB,iBAAiB,EAClB,MAAM,oCAAoC,CAAC;AAI5C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,qBAAa,uBAAwB,YAAW,sBAAsB;IAQlE,OAAO,CAAC,QAAQ,CAAC,mBAAmB;IAEpC,OAAO,CAAC,QAAQ,CAAC,sBAAsB;IATzC;;;;;OAKG;gBAEgB,mBAAmB,EAAE,mBAAmB,EAExC,sBAAsB,EAAE,sBAAsB;IAGjE;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,qBAAqB,CACnB,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,iBAAiB,GACzB,gBAAgB;IA4CnB;;;;;;;;;;;;;;;;;;;;;;;;;;OA0BG;IACH,sBAAsB,CACpB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,iBAAiB,GACzB,iBAAiB;IAsBpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8BG;IACH;;;;;;;;;;;;;OAaG;IACG,qBAAqB,CACzB,WAAW,EAAE,MAAM,GAAG,GAAG,EAAE,EAC3B,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,GAAG,SAAS,CAAC;QAAC,WAAW,EAAE,GAAG,EAAE,CAAA;KAAE,CAAC;IA+F9D,oBAAoB,CACxB,WAAW,EAAE,MAAM,GAAG,GAAG,EAAE,EAC3B,KAAK,EAAE,WAAW,EAClB,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,GAAG,EAAE,CAAC;CAoFlB"}