fix(routing): survive upstream 410 Gone + retire dead Ollama Cloud model

server/src/__tests__/db/ollama-410-v19.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect, beforeAll } from 'vitest';
+import { initDb, getDb } from '../../db/index.js';
+
+// Live-verified 2026-07-22: Ollama Cloud answers `410 Gone` for
+// qwen3-coder:480b — the hosted model was removed upstream. With
+// intelligence_rank 2 the row sat at the top of the auto-route chain, so
+// every `model: "auto"` request died on it before the 410 classifier fix.
+const RETIRED_OLLAMA_MODELS = ['qwen3-coder:480b'];
+
+// Probed the same day through /v1/chat/completions: these still answer 200.
+const LIVE_OLLAMA_MODELS = ['gemma4:31b', 'gpt-oss:120b', 'gpt-oss:20b'];
+
+describe('V19 Ollama Cloud retirement', () => {
+  beforeAll(() => {
+    process.env.ENCRYPTION_KEY = '0'.repeat(64);
+    initDb(':memory:');
+  });
+
+  it('disables the Ollama Cloud rows the upstream deleted (410 Gone)', () => {
+    const db = getDb();
+    for (const modelId of RETIRED_OLLAMA_MODELS) {
+      const row = db
+        .prepare("SELECT enabled FROM models WHERE platform = 'ollama' AND model_id = ?")
+        .get(modelId) as { enabled: number } | undefined;
+      expect(row, `${modelId} should exist in the catalog`).toBeDefined();
+      expect(row!.enabled, `${modelId} must be disabled — upstream returns 410`).toBe(0);
+    }
+  });
+
+  it('keeps the still-hosted Ollama Cloud models enabled', () => {
+    const db = getDb();
+    for (const modelId of LIVE_OLLAMA_MODELS) {
+      const row = db
+        .prepare("SELECT enabled FROM models WHERE platform = 'ollama' AND model_id = ?")
+        .get(modelId) as { enabled: number } | undefined;
+      expect(row, `${modelId} should exist in the catalog`).toBeDefined();
+      expect(row!.enabled, `${modelId} should stay enabled`).toBe(1);
+    }
+  });
+});

server/src/__tests__/providers/google.test.ts

@@ -556,6 +556,44 @@ describe('GoogleProvider', () => {
     expect(result._routed_via).toEqual({ platform: 'google', model: 'gemini-3.1-flash-image' });
   });
 
+  it('should transcribe uploaded audio through Gemini and return OpenAI-compatible JSON', async () => {
+    let capturedBody: any;
+    vi.spyOn(global, 'fetch').mockImplementation(async (_url, init) => {
+      capturedBody = JSON.parse((init as any).body);
+      return {
+        ok: true,
+        json: () => Promise.resolve({
+          candidates: [{
+            content: { parts: [{ text: 'Turn on the office light.' }] },
+            finishReason: 'STOP',
+          }],
+        }),
+      } as any;
+    });
+
+    const audio = Buffer.from('fake-wave');
+    const result = await provider.transcribeAudio(
+      'test-key',
+      {
+        file: {
+          filename: 'utterance.wav',
+          contentType: 'audio/wav',
+          data: audio,
+        },
+        response_format: 'json',
+      },
+      'gemini-2.5-flash',
+    );
+
+    expect(capturedBody.contents[0].parts[0].text).toContain('Transcribe');
+    expect(capturedBody.contents[0].parts[1]).toEqual({
+      inlineData: { mimeType: 'audio/wav', data: audio.toString('base64') },
+    });
+    expect(result.body).toEqual({ text: 'Turn on the office light.' });
+    expect(result.contentType).toBe('application/json');
+    expect(result._routed_via).toEqual({ platform: 'google', model: 'gemini-2.5-flash' });
+  });
+
   it('should generate speech and return WAV audio bytes', async () => {
     let capturedBody: any;
     vi.spyOn(global, 'fetch').mockImplementation(async (_url, init) => {

server/src/__tests__/services/provider-errors.test.ts

@@ -2,6 +2,36 @@ import { describe, expect, it } from 'vitest';
 import { canRetryProviderFailure, classifyProviderError } from '../../services/provider-errors.js';
 
 describe('provider error classification', () => {
+  it('rotates to another key when a provider organization is restricted', () => {
+    const failure = classifyProviderError(
+      new Error('Groq API error 400: Organization has been restricted. Please reach out to support.'),
+    );
+
+    expect(failure).toMatchObject({
+      category: 'auth',
+      retryable: true,
+      skipModel: false,
+    });
+    expect(failure.keyCooldownMs).toBeGreaterThan(0);
+    expect(canRetryProviderFailure(failure, 'whisper-large-v3-turbo')).toBe(true);
+  });
+
+  it('treats HTTP 410 Gone as a model-level unavailable error so routing moves on', () => {
+    const failure = classifyProviderError(
+      new Error('Ollama Cloud API error 410: Gone'),
+    );
+
+    expect(failure).toMatchObject({
+      category: 'model_unavailable',
+      retryable: true,
+      skipModel: true,
+    });
+    // auto-route: skip the retired model and continue down the chain
+    expect(canRetryProviderFailure(failure)).toBe(true);
+    // pinned request: fail honestly instead of silently switching models
+    expect(canRetryProviderFailure(failure, 'qwen3-coder:480b')).toBe(false);
+  });
+
   it('treats provider terms acceptance gates as model-level unavailable errors', () => {
     const failure = classifyProviderError(
       new Error('Groq API error 400: The model `canopylabs/orpheus-v1-english` requires terms acceptance. Please have the org admin accept the terms.'),

server/src/db/index.ts

@@ -53,6 +53,7 @@ export async function initDb(dbPath?: string): Promise<Database.Database> {
   migrateModelsV16(db);
   migrateModelsV17(db);
   migrateModelsV18(db);
+  migrateModelsV19(db);
   seedModelCapabilities(db);
   // Must follow seedModelCapabilities — that is where the image rows are seeded.
   flagPaidGoogleModels(db);
@@ -1146,6 +1147,7 @@ function seedModelCapabilities(db: Database.Database) {
     ['google', 'gemini-2.5-flash-native-audio-preview-12-2025', 'realtime_audio', 1],
     ['google', 'gemini-3.1-flash-live-preview', 'realtime_audio', 2],
     ['groq', 'whisper-large-v3-turbo', 'transcription', 1],
+    ['google', 'gemini-2.5-flash', 'transcription', 2],
     ['groq', 'whisper-large-v3-turbo', 'translation', 1],
     ['groq', 'whisper-large-v3', 'transcription', 2],
     ['groq', 'whisper-large-v3', 'translation', 2],
@@ -1695,6 +1697,22 @@ function migrateModelsV18(db: Database.Database) {
   disable.run();
 }
 
+/**
+ * V19 (July 2026): retire the Ollama Cloud rows the upstream deleted.
+ *
+ * Ollama Cloud answers `410 Gone` for qwen3-coder:480b — the hosted model was
+ * removed outright (live-verified 2026-07-22). With intelligence_rank 2 the
+ * row sat at the top of the auto-route chain, so before the 410 classifier
+ * fix every `model: "auto"` request died on it with a 502. Disabled, never
+ * deleted, per V18 precedent; a future migration can re-enable it if Ollama
+ * brings the model back.
+ */
+function migrateModelsV19(db: Database.Database) {
+  db.prepare(
+    "UPDATE models SET enabled = 0 WHERE platform = 'ollama' AND model_id = 'qwen3-coder:480b'",
+  ).run();
+}
+
 /**
  * Mark Google models that have no free tier (verified 2026-07-22 against
  * ai.google.dev pricing — image generation reads "Not available" in the Free

server/src/index.ts

@@ -5,14 +5,15 @@ import { startHealthChecker } from './services/health.js';
 import { startModelScout } from './services/model-scout.js';
 
 const PORT = process.env.PORT ?? 3001;
+const HOST = process.env.HOST ?? '127.0.0.1';
 
 async function main() {
   await initDb();
   const app = createApp();
 
-  app.listen(Number(PORT), '0.0.0.0', () => {
-    console.log(`Server running on http://0.0.0.0:${PORT}`);
-    console.log(`Proxy endpoint: http://0.0.0.0:${PORT}/v1/chat/completions`);
+  app.listen(Number(PORT), HOST, () => {
+    console.log(`Server running on http://${HOST}:${PORT}`);
+    console.log(`Proxy endpoint: http://${HOST}:${PORT}/v1/chat/completions`);
     startHealthChecker();
     startModelScout();
   });

server/src/providers/google.ts

@@ -6,6 +6,8 @@ import type {
   ChatToolCall,
   ChatToolChoice,
   ChatToolDefinition,
+  AudioTextResult,
+  AudioTranscriptionRequest,
   ImageEditRequest,
   ImageFileUpload,
   ImageGenerationRequest,
@@ -715,6 +717,62 @@ export class GoogleProvider extends BaseProvider {
     };
   }
 
+  async transcribeAudio(
+    apiKey: string,
+    request: AudioTranscriptionRequest,
+    modelId: string,
+  ): Promise<AudioTextResult> {
+    if (!request.file) {
+      throw new Error('Google transcription requires an uploaded audio file');
+    }
+
+    const instructions = [
+      'Transcribe the supplied audio exactly.',
+      'Return only the transcript without commentary, labels, quotation marks, or Markdown.',
+      request.language ? `The expected language code is ${request.language}.` : '',
+      request.prompt ? `Context that may help disambiguate names: ${request.prompt}` : '',
+    ].filter(Boolean).join(' ');
+    const body = {
+      contents: [{
+        parts: [
+          { text: instructions },
+          {
+            inlineData: {
+              mimeType: request.file.contentType || 'audio/wav',
+              data: Buffer.from(request.file.data).toString('base64'),
+            },
+          },
+        ],
+      }],
+      generationConfig: { temperature: 0 },
+    };
+
+    const url = `${API_BASE}/models/${modelId}:generateContent?key=${apiKey}`;
+    const res = await this.fetchWithTimeout(url, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify(body),
+    }, 120000);
+
+    if (!res.ok) {
+      const err = await res.json().catch(() => ({}));
+      throw new Error(`Google API error ${res.status}: ${(err as any).error?.message ?? res.statusText}`);
+    }
+
+    const data = await res.json() as GeminiResponse;
+    const transcript = extractText(data.candidates?.[0]?.content?.parts)?.trim();
+    if (!transcript) {
+      throw new Error('Google transcription returned no text');
+    }
+
+    const wantsText = request.response_format === 'text';
+    return {
+      body: wantsText ? transcript : { text: transcript },
+      contentType: wantsText ? 'text/plain; charset=utf-8' : 'application/json',
+      _routed_via: { platform: 'google', model: modelId },
+    };
+  }
+
   async createSpeech(
     apiKey: string,
     request: SpeechRequest,

server/src/services/provider-errors.ts

@@ -18,6 +18,13 @@ export function classifyProviderError(err: unknown): ClassifiedProviderError {
     return { category: 'zero_quota', retryable: true, skipModel: true, keyCooldownMs: 0 };
   }
 
+  if (
+    msg.includes('organization has been restricted')
+    || msg.includes('organization is restricted')
+  ) {
+    return { category: 'auth', retryable: true, skipModel: false, keyCooldownMs: 24 * 60 * 60 * 1000 };
+  }
+
   if (
     msg.includes('401')
     || msg.includes('unauthorized')
@@ -29,6 +36,7 @@ export function classifyProviderError(err: unknown): ClassifiedProviderError {
 
   if (
     msg.includes('404')
+    || msg.includes('410')
     || msg.includes('not found')
     || msg.includes('model does not exist')
     || msg.includes('unavailable_model')