[clousky2020]

Summary

This PR adds ModelScope provider support with comprehensive circuit breaker and fallback improvements.

Features

• ModelScope Provider: Add support for qwen, bailian-coding-plan, alicode, alicode-intl, dashscope-intl models with per-model quota management
• Provider Circuit Breaker: New circuit breaker pattern for transient errors (network timeout, rate limits) with automatic recovery
• Content Moderation Detection: Automatic detection and fallback for Chinese content moderation responses
• Daily Quota Handling: Smart detection of daily quota exhaustion with "try again tomorrow" handling
• Codex Executor: Strip stored item references to prevent 404 errors, add originator header for backend compatibility
• SSE Buffer Fix: Prevent buffer truncation from splitting SSE lines

Breaking Changes Mitigation

This PR originally contained breaking changes that have been optimized to maintain backward compatibility:

• Restored getClaudeCodeDefaultModels() with @deprecated marker
• Restored cloudCodeThinking.ts module with @deprecated markers
• Restored stripStoredItemReferences() with @deprecated marker
• Restored dataPaths.js CommonJS format
• Qwen API endpoint returns 410 Gone instead of being removed
• Electron version restored to 3.6.9

Testing

• All unit tests pass
• TypeScript type check passes
• Production build succeeds
• Coverage maintained at 60%+

Checklist

• Tests pass (npm test)
• Linting passes (npm run lint)
• Build succeeds (npm run build)
• TypeScript types added for new functions
• No hardcoded secrets
• All inputs validated with Zod schemas

[gemini-code-assist]

Code Review

This pull request implements a provider-level circuit breaker to manage transient failures and introduces a "Model Status" UI system for real-time feedback on model availability and cooldowns. It adds support for the ModelScope provider, enhances SSE stream handling to prevent memory exhaustion, and introduces detection for content moderation and daily quota limits. Review feedback highlights a bug in parsing model IDs that contain slashes, potential data loss in the SSE buffer truncation logic, and the need to synchronize circuit breaker error codes with authentication failure handling. Additionally, it was noted that one source file was incorrectly replaced with transpiled code.

[gemini-code-assist]

The PROVIDER_FAILURE_ERROR_CODES set is missing 401 and 403. The changes in combo.ts (line 53) explicitly added these codes to TRANSIENT_FOR_BREAKER with the intent of quickly opening the circuit breaker for authentication errors. To fulfill this intent, they must be included here so that recordProviderFailure is triggered.

Suggested change

	const PROVIDER_FAILURE_ERROR_CODES = new Set([429, 408, 500, 502, 503, 504]);
	const PROVIDER_FAILURE_ERROR_CODES = new Set([401, 403, 429, 408, 500, 502, 503, 504]);

[gemini-code-assist]

The logic key.split("/") is incorrect for model IDs that contain slashes (e.g., moonshotai/Kimi-K2.5). This will result in an array with more than two elements, causing the model variable to only contain a partial ID (e.g., moonshotai), which will then fail to match the entries returned by the API. Use indexOf and substring to correctly split the key into provider and the full model ID.

Suggested change

	const [provider, model] = key.split("/");
	const slashIndex = key.indexOf("/");
	const provider = key.substring(0, slashIndex);
	const model = key.substring(slashIndex + 1);

[gemini-code-assist]

The current truncation logic for sseBuffer is risky. If a single SSE line (e.g., a large JSON payload) exceeds MAX_BUFFER_SIZE, the lastIndexOf search for a newline in the discard region will fail, causing the entire buffer to be cleared. This results in data loss for long lines. A safer approach is to find the first newline after the truncation point to ensure the buffer stays within limits while preserving the integrity of the most recent SSE lines.

                if (sseBuffer.length > MAX_BUFFER_SIZE) {
                  const discardCount = sseBuffer.length - MAX_BUFFER_SIZE;
                  const nextNewline = sseBuffer.indexOf("\n", discardCount);
                  if (nextNewline !== -1) {
                    sseBuffer = sseBuffer.slice(nextNewline + 1);
                  } else {
                    // If no newline is found in the remaining buffer, it means we have a single 
                    // extremely long line. We must clear it to prevent OOM.
                    sseBuffer = "";
                  }
                }

[gemini-code-assist]

The current implementation of recordProviderFailure uses a sliding window that updates lastFailureAt on every failure. This means the failure count will only reset if there is a gap of at least 20 minutes between any two failures. A more standard circuit breaker pattern uses a fixed window starting from the first failure in a sequence. Additionally, updating lastFailureAt on every call makes the log message at line 580 misleading, as the failures could have occurred over a much longer period than PROVIDER_FAILURE_WINDOW_MS.

    // Increment failure count
    const lastFailureAt = entry ? entry.lastFailureAt : now;
    const newCount = entry ? entry.failureCount + 1 : 1;

    if (newCount >= PROVIDER_FAILURE_THRESHOLD) {
      // Threshold reached, enter cooldown
      const cooldownUntil = now + PROVIDER_COOLDOWN_MS;
      providerFailureState.set(provider, {
        failureCount: newCount,
        lastFailureAt,
        resetAfterMs: PROVIDER_FAILURE_WINDOW_MS,
        cooldownUntil,
      });
      log?.warn?.(
        `[ProviderFailure] ${provider}: ${newCount} failures in ${PROVIDER_FAILURE_WINDOW_MS / 1000}s — entering ${PROVIDER_COOLDOWN_MS / 1000}s cooldown`
      );
    } else {
      // Just increment counter
      providerFailureState.set(provider, {
        failureCount: newCount,
        lastFailureAt,
        resetAfterMs: PROVIDER_FAILURE_WINDOW_MS,
        cooldownUntil: null,
      });
    }

[gemini-code-assist]

Using local server time to calculate the daily quota reset is unreliable because AI providers typically reset quotas based on a specific timezone (e.g., UTC or Beijing Time for ModelScope). If the server is in a different timezone, the model might be locked out for significantly longer than necessary or unlocked too early. Using UTC is generally a safer default for cross-region API interactions.

export function getMsUntilTomorrow(): number {
  const now = new Date();
  const tomorrow = new Date(now);
  tomorrow.setUTCHours(24, 0, 0, 0); // Next midnight UTC
  const ms = tomorrow.getTime() - now.getTime();
  // Guard against DST edge cases: if ms is negative (shouldn't happen) or
  // unreasonably large (>25h due to spring-forward), cap at 24 hours.
  return ms > 0 && ms <= 25 * 60 * 60 * 1000 ? ms : 24 * 60 * 60 * 1000;
}

[gemini-code-assist]

This file appears to have been replaced with transpiled/machine-generated code (containing __importDefault, exports.APP_NAME, etc.) instead of maintaining the original ESM source format. Committing build artifacts or transpiled code as source makes the codebase difficult to read and maintain. Please revert this file to its original hand-written source format.