open-sse/services/accountFallback.js

@@ -185,13 +185,9 @@ export function resetAccountState(account) {
   if (!account) return account;
   return {
     ...account,
-    ...buildClearModelLocksUpdate(account),
     rateLimitedUntil: null,
     backoffLevel: 0,
-    testStatus: "active",
     lastError: null,
-    errorCode: null,
-    lastErrorAt: null,
     status: "active"
   };
 }

open-sse/translator/request/openai-to-claude.js

@@ -96,40 +96,6 @@ export function openaiToClaudeRequest(model, body, stream) {
 
     flushCurrentMessage();
 
-    // GUARD: some Claude auth channels (OAuth/Claude Code) reject requests
-    // that end on an assistant turn ("assistant message prefill" 400).
-    // Agentic loops (e.g. Hermes) sometimes resend their own last output as
-    // the new final message to request a continuation, with no new user
-    // turn in between. Normalize by appending a synthetic turn so the
-    // request always ends on `user`, regardless of auth channel or model.
-    // If the trailing assistant message has unresolved tool_use blocks,
-    // Anthropic separately requires a matching tool_result for each one
-    // (not just any user turn), so synthesize those instead of plain text.
-    {
-      const lastMsg = result.messages[result.messages.length - 1];
-      if (lastMsg && lastMsg.role === ROLE.ASSISTANT) {
-        const unresolvedToolUseIds = Array.isArray(lastMsg.content)
-          ? lastMsg.content.filter(b => b.type === CLAUDE_BLOCK.TOOL_USE).map(b => b.id)
-          : [];
-
-        if (unresolvedToolUseIds.length > 0) {
-          result.messages.push({
-            role: ROLE.USER,
-            content: unresolvedToolUseIds.map(id => ({
-              type: CLAUDE_BLOCK.TOOL_RESULT,
-              tool_use_id: id,
-              content: "Continuing."
-            }))
-          });
-        } else {
-          result.messages.push({
-            role: ROLE.USER,
-            content: [{ type: CLAUDE_BLOCK.TEXT, text: "Continue." }]
-          });
-        }
-      }
-    }
-
     // Add cache_control to last assistant message
     for (let i = result.messages.length - 1; i >= 0; i--) {
       const message = result.messages[i];

src/lib/db/repos/connectionsRepo.js

@@ -189,14 +189,13 @@ export async function createProviderConnection(data) {
 }
 
 // Critical: OAuth refresh token race — atomic merge inside transaction
-export async function updateProviderConnection(id, update) {
+export async function updateProviderConnection(id, data) {
   const db = await getAdapter();
   let result;
   db.transaction(() => {
     const row = db.get(`SELECT * FROM providerConnections WHERE id = ?`, [id]);
     if (!row) { result = null; return; }
     const existing = rowToConn(row);
-    const data = typeof update === "function" ? update(existing) : update;
     const merged = { ...existing, ...data, updatedAt: new Date().toISOString() };
     upsert(db, merged);
     if (data.priority !== undefined) reorderInTx(db, existing.provider);

src/sse/handlers/stt.js

@@ -1,6 +1,6 @@
 import {
   extractApiKey, isValidApiKey,
-  getProviderCredentials, markAccountUnavailable, clearAccountError,
+  getProviderCredentials, markAccountUnavailable,
 } from "../services/auth.js";
 import { getSettings } from "@/lib/localDb";
 import { getModelInfo } from "../services/model.js";
@@ -74,10 +74,7 @@ export async function handleStt(request) {
 
     const result = await handleSttCore({ provider, model, formData, credentials, sttConfig: AI_PROVIDERS[provider]?.sttConfig });
 
-    if (result.success) {
+    if (result.success) return result.response;
-      await clearAccountError(credentials.connectionId, credentials, model);
-      return result.response;
-    }
 
     const { shouldFallback } = await markAccountUnavailable(credentials.connectionId, result.status, result.error, provider, model);
     if (shouldFallback) {

src/sse/handlers/tts.js

@@ -1,6 +1,6 @@
 import {
   extractApiKey, isValidApiKey,
-  getProviderCredentials, markAccountUnavailable, clearAccountError,
+  getProviderCredentials, markAccountUnavailable,
 } from "../services/auth.js";
 import { getSettings } from "@/lib/localDb";
 import { getModelInfo, getComboModels } from "../services/model.js";
@@ -101,10 +101,7 @@ async function handleSingleModelTts(body, modelStr, responseFormat, language, st
 
     const result = await handleTtsCore({ provider, model, input: body.input, credentials, responseFormat, language, style });
 
-    if (result.success) {
+    if (result.success) return result.response;
-      await clearAccountError(credentials.connectionId, credentials, model);
-      return result.response;
-    }
 
     const { shouldFallback } = await markAccountUnavailable(credentials.connectionId, result.status, result.error, provider, model);
     if (shouldFallback) {

src/sse/services/auth.js

@@ -1,6 +1,6 @@
 import { getProviderConnections, validateApiKey, updateProviderConnection, getSettings, getProxyPools } from "@/lib/localDb";
 import { resolveConnectionProxyConfig, pickProxyPoolId } from "@/lib/network/connectionProxy";
-import { formatRetryAfter, checkFallbackError, isModelLockActive, buildModelLockUpdate, getEarliestModelLockUntil, resetAccountState } from "open-sse/services/accountFallback.js";
+import { formatRetryAfter, checkFallbackError, isModelLockActive, buildModelLockUpdate, getEarliestModelLockUntil } from "open-sse/services/accountFallback.js";
 import { MAX_RATE_LIMIT_COOLDOWN_MS } from "open-sse/config/errorConfig.js";
 import { resolveProviderId, FREE_PROVIDERS } from "@/shared/constants/providers.js";
 import * as log from "../utils/logger.js";
@@ -274,8 +274,43 @@ export async function markAccountUnavailable(connectionId, status, errorText, pr
  */
 export async function clearAccountError(connectionId, currentConnection, model = null) {
   if (!connectionId || connectionId === "noauth") return;
-  // Reset inside transaction so concurrent 429 writes cannot leave stale locks.
+  const conn = currentConnection._connection || currentConnection;
-  await updateProviderConnection(connectionId, resetAccountState);
+  const now = Date.now();
+  const allLockKeys = Object.keys(conn).filter(k => k.startsWith("modelLock_"));
+
+  if (!conn.testStatus && !conn.lastError && allLockKeys.length === 0) return;
+
+  // Keys to clear: current model's lock + all expired locks
+  const keysToClear = allLockKeys.filter(k => {
+    if (model && k === `modelLock_${model}`) return true; // succeeded model
+    if (model && k === "modelLock___all") return true;    // account-level lock
+    const expiry = conn[k];
+    return expiry && new Date(expiry).getTime() <= now;   // expired
+  });
+
+  if (keysToClear.length === 0 && conn.testStatus !== "unavailable" && !conn.lastError) return;
+
+  // Check if any active locks remain after clearing
+  const remainingActiveLocks = allLockKeys.filter(k => {
+    if (keysToClear.includes(k)) return false;
+    const expiry = conn[k];
+    return expiry && new Date(expiry).getTime() > now;
+  });
+
+  const clearObj = Object.fromEntries(keysToClear.map(k => [k, null]));
+
+  // Only reset error state if no active locks remain
+  if (remainingActiveLocks.length === 0) {
+    Object.assign(clearObj, {
+      testStatus: "active",
+      lastError: null,
+      errorCode: null,
+      lastErrorAt: null,
+      backoffLevel: 0
+    });
+  }
+
+  await updateProviderConnection(connectionId, clearObj);
 }
 
 /**

tests/unit/account-fallback-reset.test.js

@@ -1,16 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { applyErrorState, resetAccountState } from "../../open-sse/services/accountFallback.js";
-
-describe("resetAccountState", () => {
-  it("clears every model lock and backoff after success", () => {
-    const reset = resetAccountState({ backoffLevel: 9, modelLock_alpha: "2099-01-01T00:00:00.000Z", modelLock___all: "2099-01-01T00:00:00.000Z", lastError: "429", errorCode: 429 });
-    expect(reset.backoffLevel).toBe(0);
-    expect(reset.modelLock_alpha).toBeNull();
-    expect(reset.modelLock___all).toBeNull();
-    expect(reset.lastError).toBeNull();
-  });
-
-  it("keeps 429 on error path ratcheting upward", () => {
-    expect(applyErrorState({ backoffLevel: 3 }, 429, "rate limited").backoffLevel).toBe(4);
-  });
-});