shortcutxl 0.2.0

package/dist/core/session-models.js

@@ -0,0 +1,99 @@
+/**
+ * Model and thinking level management — pure logic.
+ *
+ * Extracted from AgentSession. All functions are pure (no side effects).
+ * AgentSession delegates to these for cycling math and level clamping,
+ * then handles persistence and extension events itself.
+ */
+import { modelsAreEqual, supportsXhigh } from '@mariozechner/pi-ai';
+// ============================================================================
+// Constants
+// ============================================================================
+/** Standard thinking levels (ordered low → high) */
+export const THINKING_LEVELS = ['off', 'minimal', 'low', 'medium', 'high'];
+/** Thinking levels including xhigh (for supported models) */
+export const THINKING_LEVELS_WITH_XHIGH = [
+    'off',
+    'minimal',
+    'low',
+    'medium',
+    'high',
+    'xhigh'
+];
+// ============================================================================
+// Thinking Level Logic
+// ============================================================================
+/** Check if a model supports thinking/reasoning. */
+export function supportsThinking(model) {
+    return !!model?.reasoning;
+}
+/** Check if a model supports xhigh thinking. */
+export function supportsXhighThinking(model) {
+    return model ? supportsXhigh(model) : false;
+}
+/** Get available thinking levels for a given model. */
+export function getAvailableThinkingLevels(model) {
+    if (!supportsThinking(model))
+        return ['off'];
+    return supportsXhighThinking(model) ? THINKING_LEVELS_WITH_XHIGH : THINKING_LEVELS;
+}
+/**
+ * Clamp a thinking level to the nearest available level.
+ * Searches forward first (higher levels), then backward (lower levels).
+ */
+export function clampThinkingLevel(level, availableLevels) {
+    if (availableLevels.includes(level))
+        return level;
+    const ordered = THINKING_LEVELS_WITH_XHIGH;
+    const available = new Set(availableLevels);
+    const requestedIndex = ordered.indexOf(level);
+    if (requestedIndex === -1) {
+        return availableLevels[0] ?? 'off';
+    }
+    // Search forward (higher levels)
+    for (let i = requestedIndex; i < ordered.length; i++) {
+        const candidate = ordered[i];
+        if (available.has(candidate))
+            return candidate;
+    }
+    // Search backward (lower levels)
+    for (let i = requestedIndex - 1; i >= 0; i--) {
+        const candidate = ordered[i];
+        if (available.has(candidate))
+            return candidate;
+    }
+    return availableLevels[0] ?? 'off';
+}
+/**
+ * Compute the next thinking level in a cycle.
+ * @returns The next level, or undefined if model doesn't support thinking.
+ */
+export function cycleThinkingLevel(currentLevel, model) {
+    if (!supportsThinking(model))
+        return undefined;
+    const levels = getAvailableThinkingLevels(model);
+    const currentIndex = levels.indexOf(currentLevel);
+    const nextIndex = (currentIndex + 1) % levels.length;
+    return levels[nextIndex];
+}
+// ============================================================================
+// Model Cycling Logic
+// ============================================================================
+/**
+ * Compute the next model in the cycle.
+ * Pure index math — does not mutate state.
+ * @returns The next model, or undefined if ≤1 model available.
+ */
+export function computeNextModel(availableModels, currentModel, direction) {
+    if (availableModels.length <= 1)
+        return undefined;
+    let currentIndex = currentModel
+        ? availableModels.findIndex((m) => modelsAreEqual(m, currentModel))
+        : -1;
+    if (currentIndex === -1)
+        currentIndex = 0;
+    const len = availableModels.length;
+    const nextIndex = direction === 'forward' ? (currentIndex + 1) % len : (currentIndex - 1 + len) % len;
+    return availableModels[nextIndex];
+}
+//# sourceMappingURL=session-models.js.map

package/dist/core/session-retry.js

@@ -0,0 +1,155 @@
+/**
+ * Session retry state machine.
+ *
+ * Extracted from AgentSession to be independently testable.
+ * Handles exponential backoff for retryable LLM errors
+ * (overloaded, rate limit, server errors).
+ *
+ * Context overflow errors are NOT handled here — those go through compaction.
+ */
+import { sleep } from '../utils/sleep.js';
+// ============================================================================
+// Error Classification
+// ============================================================================
+const RETRYABLE_ERROR_PATTERN = /overloaded|rate.?limit|too many requests|429|500|502|503|504|service.?unavailable|server error|internal error|connection.?error|connection.?refused|other side closed|fetch failed|upstream.?connect|reset before headers|terminated|retry delay/i;
+export function isRetryableError(message, isContextOverflow) {
+    if (message.stopReason !== 'error' || !message.errorMessage)
+        return false;
+    if (isContextOverflow(message))
+        return false;
+    return RETRYABLE_ERROR_PATTERN.test(message.errorMessage);
+}
+// ============================================================================
+// Retry State Machine
+// ============================================================================
+export class SessionRetry {
+    _abortController = undefined;
+    _attempt = 0;
+    _promise = undefined;
+    _resolve = undefined;
+    _listener = undefined;
+    get attempt() {
+        return this._attempt;
+    }
+    get isRetrying() {
+        return this._promise !== undefined;
+    }
+    onEvent(listener) {
+        this._listener = listener;
+    }
+    _emit(event) {
+        this._listener?.(event);
+    }
+    /** Reset all state to idle. */
+    _reset() {
+        this._attempt = 0;
+        this._resolve?.();
+        this._resolve = undefined;
+        this._promise = undefined;
+    }
+    /**
+     * Create the retry promise synchronously when an agent_end event arrives.
+     *
+     * This MUST be called synchronously from the agent event handler, before
+     * any async processing. The reason: agent.prompt() resolves as soon as
+     * agent_end fires, and the caller immediately calls wait().
+     * If the promise isn't created yet, wait() returns immediately
+     * and the caller proceeds before the retry completes.
+     */
+    prepareForAgentEnd(lastAssistant, isContextOverflow, settings) {
+        if (this._promise)
+            return false;
+        if (!settings.enabled)
+            return false;
+        if (!lastAssistant || !isRetryableError(lastAssistant, isContextOverflow))
+            return false;
+        this._promise = new Promise((resolve) => {
+            this._resolve = resolve;
+        });
+        return true;
+    }
+    /**
+     * Handle a retryable error. Called from the async agent_end processing.
+     * @returns true if retry was initiated, false if disabled or max retries exceeded
+     */
+    async handleRetryableError(message, settings, actions) {
+        if (!settings.enabled) {
+            this._reset();
+            return false;
+        }
+        // Defensive fallback: create promise if prepareForAgentEnd wasn't called.
+        // This happens when handleRetryableError is called outside the normal
+        // agent_end → processAgentEvent flow (e.g. direct invocation in tests
+        // or future refactors that bypass the synchronous prepare step).
+        if (!this._promise) {
+            this._promise = new Promise((resolve) => {
+                this._resolve = resolve;
+            });
+        }
+        this._attempt++;
+        if (this._attempt > settings.maxRetries) {
+            this._emit({
+                type: 'auto_retry_end',
+                success: false,
+                attempt: this._attempt - 1,
+                finalError: message.errorMessage
+            });
+            this._reset();
+            return false;
+        }
+        const delayMs = Math.min(settings.baseDelayMs * 2 ** (this._attempt - 1), settings.maxDelayMs);
+        this._emit({
+            type: 'auto_retry_start',
+            attempt: this._attempt,
+            maxAttempts: settings.maxRetries,
+            delayMs,
+            errorMessage: message.errorMessage || 'Unknown error'
+        });
+        actions.removeLastAssistantMessage();
+        this._abortController = new AbortController();
+        try {
+            await sleep(delayMs, this._abortController.signal);
+        }
+        catch {
+            const attempt = this._attempt;
+            this._abortController = undefined;
+            this._emit({
+                type: 'auto_retry_end',
+                success: false,
+                attempt,
+                finalError: 'Retry cancelled'
+            });
+            this._reset();
+            return false;
+        }
+        this._abortController = undefined;
+        actions.continue();
+        return true;
+    }
+    /**
+     * Called when a successful assistant response arrives mid-retry.
+     * Resets the retry counter and resolves the promise.
+     */
+    onSuccess() {
+        if (this._attempt <= 0)
+            return;
+        this._emit({
+            type: 'auto_retry_end',
+            success: true,
+            attempt: this._attempt
+        });
+        this._reset();
+    }
+    /** Cancel in-progress retry. */
+    abort() {
+        this._abortController?.abort();
+        this._reset();
+    }
+    /** Wait for any in-progress retry to complete. */
+    async wait() {
+        if (this._promise) {
+            await this._promise;
+        }
+    }
+}
+//# sourceMappingURL=session-retry.js.map