@gotcos/glasses-server 6.15.3 → 6.16.0

package/server/lib/whisper-local.ts

@@ -6,10 +6,10 @@
 //   2. whisper-cli (spawned per request, model loaded from disk) → ~500-700ms
 //   3. OpenAI API (cloud, handled by transcribe.ts) → ~1000-3000ms
 
-import { spawn, execFileSync } from 'node:child_process'
+import { spawn, execFile } from 'node:child_process'
 import type { ChildProcess } from 'node:child_process'
 import { writeFileSync, unlinkSync, existsSync, readFileSync } from 'node:fs'
-import { join } from 'node:path'
+import { basename, join } from 'node:path'
 import { homedir } from 'node:os'
 import crypto from 'node:crypto'
 import { getVocabulary, getOwnerName } from './profile.js'
@@ -42,6 +42,49 @@ export interface WhisperSegment {
   words?: WhisperWord[]
 }
 
+export type HighQualityUnavailableReason =
+  | 'hq_disabled'
+  | 'whisper_cli_missing'
+  | 'turbo_model_missing'
+  | 'large_v3_model_missing'
+
+export interface HighQualityTranscriptionCapability {
+  hqAvailable: boolean
+  model: 'large-v3' | null
+  backend: 'whisper-cli' | null
+  reason: HighQualityUnavailableReason | null
+}
+
+export interface HighQualityTranscriptionResult {
+  text: string
+  words?: WhisperWord[]
+  model: 'large-v3' | 'turbo'
+  backend: 'whisper-cli' | 'whisper-server'
+  actualQuality: 'hq' | 'fast'
+  degradationReason?: HighQualityUnavailableReason
+}
+
+export function classifyHighQualityTranscriptionCapability(input: {
+  enabled: boolean
+  cliPresent: boolean
+  turboReady: boolean
+  largeV3Present: boolean
+}): HighQualityTranscriptionCapability {
+  if (!input.enabled) {
+    return { hqAvailable: false, model: null, backend: null, reason: 'hq_disabled' }
+  }
+  if (!input.cliPresent) {
+    return { hqAvailable: false, model: null, backend: null, reason: 'whisper_cli_missing' }
+  }
+  if (!input.turboReady) {
+    return { hqAvailable: false, model: null, backend: null, reason: 'turbo_model_missing' }
+  }
+  if (!input.largeV3Present) {
+    return { hqAvailable: false, model: null, backend: null, reason: 'large_v3_model_missing' }
+  }
+  return { hqAvailable: true, model: 'large-v3', backend: 'whisper-cli', reason: null }
+}
+
 interface WhisperJsonResponse {
   text?: unknown
 }
@@ -137,6 +180,10 @@ function getWhisperPrompt(): string {
 // whisper-server runs on this port (started at server boot or by LaunchAgent)
 const WHISPER_SERVER_PORT = 8178
 const WHISPER_SERVER_URL = `http://127.0.0.1:${WHISPER_SERVER_PORT}`
+const PROCESS_PROBE_TIMEOUT_MS = 2_000
+const PROCESS_PROBE_MAX_BUFFER = 1024 * 1024
+const PS_BIN = '/bin/ps'
+const LSOF_BIN = existsSync('/usr/sbin/lsof') ? '/usr/sbin/lsof' : 'lsof'
 
 // Track which backends are available
 let cliAvailable = false
@@ -153,6 +200,10 @@ let serverStarting = false            // Initial model load is not a circuit fai
 let serverStartPromise: Promise<void> | null = null
 let serverRestartPromise: Promise<WhisperRestartResult> | null = null
 let serverHealthProbe: Promise<boolean> | null = null
+type WhisperStartupState = 'not_started' | 'preflight' | 'loading' | 'ready' | 'unavailable' | 'failed' | 'stopped'
+let serverStartupState: WhisperStartupState = 'not_started'
+let serverLastAttemptAt: string | null = null
+let serverLastError: string | null = null
 
 interface ProcessEntry {
   pid: number
@@ -167,10 +218,34 @@ export interface WhisperRestartResult {
 
 const sleep = (ms: number): Promise<void> => new Promise(resolve => setTimeout(resolve, ms))
 
-function listProcesses(): ProcessEntry[] {
+function boundedError(value: unknown): string {
+  const message = value instanceof Error ? value.message : String(value)
+  return message.replace(/[\r\n\t]+/g, ' ').slice(0, 240)
+}
+
+function runProcessProbe(file: string, args: string[]): Promise<string> {
+  return new Promise((resolve, reject) => {
+    execFile(file, args, {
+      encoding: 'utf8',
+      timeout: PROCESS_PROBE_TIMEOUT_MS,
+      maxBuffer: PROCESS_PROBE_MAX_BUFFER,
+      killSignal: 'SIGKILL',
+    }, (error, stdout) => {
+      if (error) reject(error)
+      else resolve(String(stdout))
+    })
+  })
+}
+
+async function listProcesses(): Promise<ProcessEntry[]> {
   // `command=` includes arguments, which lets us distinguish this COS-owned
   // port/model signature from unrelated whisper-server instances.
-  const output = execFileSync('ps', ['-axww', '-o', 'pid=,ppid=,command='], { encoding: 'utf8' })
+  let output: string
+  try {
+    output = await runProcessProbe(PS_BIN, ['-axww', '-o', 'pid=,ppid=,command='])
+  } catch (error) {
+    throw new Error(`unable to inspect process table: ${boundedError(error)}`)
+  }
   return output.split('\n').flatMap(line => {
     const match = line.match(/^\s*(\d+)\s+(\d+)\s+(.+?)\s*$/)
     if (!match) return []
@@ -178,24 +253,25 @@ function listProcesses(): ProcessEntry[] {
   })
 }
 
-function listeningPids(): number[] {
+async function listeningPids(): Promise<number[]> {
   try {
-    const output = execFileSync(
-      'lsof',
+    const output = await runProcessProbe(
+      LSOF_BIN,
       ['-nP', `-iTCP:${WHISPER_SERVER_PORT}`, '-sTCP:LISTEN', '-t'],
-      { encoding: 'utf8' },
     )
     return output.split(/\s+/).map(Number).filter(pid => Number.isInteger(pid) && pid > 0)
   } catch (err: any) {
     // lsof uses exit 1 for "no matches". Anything else means we could not
     // prove the port state, so startup must fail closed.
-    if (err?.status === 1) return []
-    throw new Error(`unable to inspect whisper-server port ${WHISPER_SERVER_PORT}: ${err?.message ?? err}`)
+    if (err?.code === 1 || err?.status === 1) return []
+    throw new Error(`unable to inspect whisper-server port ${WHISPER_SERVER_PORT}: ${boundedError(err)}`)
   }
 }
 
 function isCosWhisperServerCommand(command: string): boolean {
-  const executable = /(?:^|\s)(?:\S*\/)?whisper-server(?:\s|$)/.test(command)
+  const firstToken = command.trim().match(/^(?:"([^"]+)"|'([^']+)'|(\S+))/)
+  const executablePath = firstToken?.[1] ?? firstToken?.[2] ?? firstToken?.[3] ?? ''
+  const executable = basename(executablePath) === 'whisper-server'
   const configuredPort = new RegExp(`(?:^|\\s)--port(?:=|\\s+)${WHISPER_SERVER_PORT}(?:\\s|$)`).test(command)
   return executable && configuredPort && command.includes(MODEL_PATH)
 }
@@ -249,7 +325,7 @@ async function killAndReapWhisperProcesses(): Promise<void> {
   serverAvailable = false
 
   for (let round = 0; round < 3; round++) {
-    const processes = listProcesses()
+    const processes = await listProcesses()
     const ownedPids = [...ownedServerChildren]
       .map(child => child.pid)
       .filter((pid): pid is number => typeof pid === 'number')
@@ -288,7 +364,7 @@ async function killAndReapWhisperProcesses(): Promise<void> {
     await sleep(50)
   }
 
-  const remaining = listProcesses().filter(entry => isCosWhisperServerCommand(entry.command))
+  const remaining = (await listProcesses()).filter(entry => isCosWhisperServerCommand(entry.command))
   if (remaining.length > 0) {
     throw new Error(`stale whisper-server process(es) remain: ${remaining.map(entry => entry.pid).join(', ')}`)
   }
@@ -298,11 +374,11 @@ async function killAndReapWhisperProcesses(): Promise<void> {
 
 async function proveWhisperPortClear(): Promise<void> {
   for (let attempt = 0; attempt < 20; attempt++) {
-    const pids = listeningPids()
+    const pids = await listeningPids()
     if (pids.length === 0) return
     if (attempt < 19) await sleep(250)
   }
-  const pids = listeningPids()
+  const pids = await listeningPids()
   throw new Error(
     `whisper-server port ${WHISPER_SERVER_PORT} remains occupied${pids.length ? ` by PID(s) ${pids.join(', ')}` : ''}`,
   )
@@ -334,10 +410,17 @@ export async function startWhisperServer(): Promise<void> {
   if (serverAvailable && serverProcess) return
 
   serverStarting = true
+  serverStartupState = 'preflight'
+  serverLastAttemptAt = new Date().toISOString()
+  serverLastError = null
   const operation = startWhisperServerAttempt()
   serverStartPromise = operation
   try {
     await operation
+  } catch (error) {
+    serverStartupState = 'failed'
+    serverLastError = boundedError(error)
+    throw error
   } finally {
     if (serverStartPromise === operation) serverStartPromise = null
     serverStarting = false
@@ -346,6 +429,8 @@ export async function startWhisperServer(): Promise<void> {
 
 async function startWhisperServerAttempt(preflightCompleted = false): Promise<void> {
   if (!existsSync(WHISPER_SERVER) || !existsSync(MODEL_PATH)) {
+    serverStartupState = 'unavailable'
+    serverLastError = 'whisper-server or model not found'
     console.log('[whisper-local] whisper-server or model not found — using CLI fallback')
     return
   }
@@ -353,9 +438,12 @@ async function startWhisperServerAttempt(preflightCompleted = false): Promise<vo
   // The API process is the sole Whisper owner. Never adopt an untracked daemon:
   // reap stale trees, then prove the fixed local port is free before spawning.
   if (!preflightCompleted) {
+    console.log('[whisper-local] preflight: inspecting owned processes and port 8178')
+    serverStartupState = 'preflight'
     await killAndReapWhisperProcesses()
     await proveWhisperPortClear()
   }
+  serverStartupState = 'loading'
 
   // Assemble startup args. VAD only attaches if the ggml model is actually on
   // disk — missing-file is logged, not fatal (server still boots without VAD).
@@ -402,6 +490,8 @@ async function startWhisperServerAttempt(preflightCompleted = false): Promise<vo
     if (serverProcess !== child) return
     serverAvailable = false
     serverProcess = null
+    serverStartupState = 'failed'
+    serverLastError = `whisper-server exited${code == null ? '' : ` with code ${code}`}`
     if (code !== null && code !== 0) {
       console.warn(`[whisper-local] whisper-server exited with code ${code}`)
     }
@@ -422,6 +512,8 @@ async function startWhisperServerAttempt(preflightCompleted = false): Promise<vo
       const res = await fetch(`${WHISPER_SERVER_URL}/health`, { signal: AbortSignal.timeout(1000) })
       if (res.ok) {
         serverAvailable = true
+        serverStartupState = 'ready'
+        serverLastError = null
         const loadTime = ((Date.now() - startTime) / 1000).toFixed(1)
         console.log(`[whisper-local] whisper-server ready on port ${WHISPER_SERVER_PORT} (loaded in ${loadTime}s)`)
         return
@@ -444,6 +536,8 @@ async function startWhisperServerAttempt(preflightCompleted = false): Promise<vo
   console.error(`[whisper-local] ${failure} — reaping child and keeping local backend unavailable`)
   await killAndReapWhisperProcesses()
   await proveWhisperPortClear()
+  serverStartupState = 'failed'
+  serverLastError = failure
   throw new Error(failure)
 }
 
@@ -461,6 +555,7 @@ export function stopWhisperServer(): void {
     try { proc.kill('SIGKILL') } catch { /* already exited */ }
   }
   ownedHqChildren.clear()
+  serverStartupState = 'stopped'
 }
 
 export function isWhisperLocalAvailable(): boolean {
@@ -480,20 +575,42 @@ export function getWhisperBackend(): 'server' | 'cli' | 'none' {
 /** Detailed health status for diagnostics (/api/health) */
 export function getWhisperHealth(): {
   server: boolean
+  serverConfigured: boolean
   cli: boolean
   consecutiveFailures: number
   restarting: boolean
   circuitOpen: boolean
+  startupState: WhisperStartupState
+  lastAttemptAt: string | null
+  lastError: string | null
 } {
   return {
     server: serverAvailable,
+    serverConfigured: existsSync(WHISPER_SERVER) && existsSync(MODEL_PATH),
     cli: cliAvailable,
     consecutiveFailures: serverConsecutiveFailures,
     restarting: serverRestarting || serverStarting,
     circuitOpen: serverConsecutiveFailures >= SERVER_FAILURE_THRESHOLD,
+    startupState: serverStartupState,
+    lastAttemptAt: serverLastAttemptAt,
+    lastError: serverLastError,
   }
 }
 
+/** Public, path-free truth about whether an HQ request can actually run the
+ * full large-v3 decoder. Keep this separate from generic Whisper liveness: the
+ * persistent turbo server may be healthy while HQ weights or the CLI are not. */
+export function getHighQualityTranscriptionCapability(): HighQualityTranscriptionCapability {
+  // cliAvailable also proves the turbo model exists. That fallback is part of
+  // the current decoder contract and is initialized once at process startup.
+  return classifyHighQualityTranscriptionCapability({
+    enabled: BATCH_LARGE_V3_ENABLED,
+    cliPresent: existsSync(WHISPER_CLI),
+    turboReady: cliAvailable,
+    largeV3Present: existsSync(BATCH_MODEL_LARGE_V3),
+  })
+}
+
 /**
  * Reconcile a cached unavailable flag with the daemon's live health endpoint.
  * Only successful inference resets the failure count: /health can be responsive
@@ -581,10 +698,18 @@ export async function transcribeHighQuality(
   audioBuffer: Buffer,
   context?: string,
   opts: { priority?: 'interactive' | 'batch' } = {},
-): Promise<{ text: string; words?: WhisperWord[] }> {
+): Promise<HighQualityTranscriptionResult> {
   if (!cliAvailable) {
     // Fall back to server (no beam search available via HTTP API)
-    return transcribeLocal(audioBuffer, context)
+    const fallback = await transcribeLocal(audioBuffer, context)
+    return {
+      text: fallback.text,
+      words: fallback.words,
+      model: 'turbo',
+      backend: fallback.backend === 'server' ? 'whisper-server' : 'whisper-cli',
+      actualQuality: 'fast',
+      degradationReason: existsSync(WHISPER_CLI) ? 'turbo_model_missing' : 'whisper_cli_missing',
+    }
   }
 
   const start = Date.now()
@@ -604,14 +729,22 @@ export async function transcribeHighQuality(
 
     const text = await new Promise<string>((resolve, reject) => {
       const isolateBatchFromLiveMetal = opts.priority === 'batch'
+      // Interactive HQ: narrower beam (default 2) for latency. Meeting batch keeps 5.
+      // Override: COS_HQ_BEAM_INTERACTIVE=N
+      const interactiveBeamRaw = Number.parseInt(process.env.COS_HQ_BEAM_INTERACTIVE || '2', 10)
+      const interactiveBeam = Number.isFinite(interactiveBeamRaw) && interactiveBeamRaw >= 1
+        ? Math.min(interactiveBeamRaw, 5)
+        : 2
+      const beam = isolateBatchFromLiveMetal ? 5 : interactiveBeam
+      const bestOf = beam
       const args = [
         '-m', modelPath,
         '-f', tmpWav,
         '-t', isolateBatchFromLiveMetal ? '8' : '16',
         '-l', 'en',
         ...(isolateBatchFromLiveMetal ? ['-ng'] : ['-fa']),
-        '-bs', '5',           // Beam search width 5 (default disabled)
-        '-bo', '5',           // Best-of-5 candidates (default 2)
+        '-bs', String(beam),
+        '-bo', String(bestOf),
         '--no-timestamps',
         '-np',
         '--prompt', buildPrompt(context),
@@ -701,7 +834,17 @@ export async function transcribeHighQuality(
       `${words ? `, ${words.length} words` : ''}): ` +
       `"${corrected.slice(0, 80)}${corrected.length > 80 ? '...' : ''}"`,
     )
-    return words ? { text: corrected, words } : { text: corrected }
+    const metadata = useLargeV3
+      ? { model: 'large-v3' as const, backend: 'whisper-cli' as const, actualQuality: 'hq' as const }
+      : {
+          model: 'turbo' as const,
+          backend: 'whisper-cli' as const,
+          actualQuality: 'fast' as const,
+          degradationReason: BATCH_LARGE_V3_ENABLED
+            ? 'large_v3_model_missing' as const
+            : 'hq_disabled' as const,
+        }
+    return words ? { text: corrected, words, ...metadata } : { text: corrected, ...metadata }
   } finally {
     try { unlinkSync(tmpWav) } catch { /* cleanup */ }
     if (captureBatchWords) {
@@ -966,6 +1109,9 @@ export async function restartWhisperServer(): Promise<WhisperRestartResult> {
   if (serverRestartPromise) return serverRestartPromise
 
   serverRestarting = true
+  serverStartupState = 'preflight'
+  serverLastAttemptAt = new Date().toISOString()
+  serverLastError = null
   const priorStart = serverStartPromise
   const operation = (async (): Promise<WhisperRestartResult> => {
     try {
@@ -984,6 +1130,8 @@ export async function restartWhisperServer(): Promise<WhisperRestartResult> {
         throw new Error('whisper-server did not become healthy')
       }
       serverConsecutiveFailures = 0
+      serverStartupState = 'ready'
+      serverLastError = null
       console.log('[whisper-local] Server restarted successfully — circuit breaker CLOSED')
       return { status: 'recovered' }
     } catch (err: any) {
@@ -992,6 +1140,8 @@ export async function restartWhisperServer(): Promise<WhisperRestartResult> {
       // breaker cycle, and the next three failed calls may request one new cycle.
       serverConsecutiveFailures = 0
       const message = err?.message ?? String(err)
+      serverStartupState = 'failed'
+      serverLastError = boundedError(message)
       console.error(`[whisper-local] Server restart error: ${message} — will retry after next 3 failures`)
       return { status: 'failed', error: message }
     }

package/server/routes/health.ts

@@ -8,7 +8,11 @@ import { getServerInstanceId } from '../lib/server-instance-id.js'
 import { localFirstMeetingsCapability } from '../lib/local-first-meetings-contract.js'
 import { isSileroAvailable } from '../lib/vad-silero.js'
 import { getAvailableCliSessionId } from '../lib/claude-bridge.js'
-import { isWhisperLocalAvailable, getWhisperHealth } from '../lib/whisper-local.js'
+import {
+  isWhisperLocalAvailable,
+  getWhisperHealth,
+  getHighQualityTranscriptionCapability,
+} from '../lib/whisper-local.js'
 import { getOpenAIWhisperBudgetState } from '../lib/openai-whisper-budget.js'
 import { getKeyStatus } from '../lib/openai-key.js'
 import {
@@ -150,6 +154,7 @@ healthRouter.get('/health', async (_req, res) => {
   const durableJobs = durableQueryJobStatus()
   const localFirstMeetings = localFirstMeetingsCapability(getServerInstanceId())
   const transcription = getTranscriptionPolicySnapshot()
+  const transcriptionHq = getHighQualityTranscriptionCapability()
   const recovery = managedRuntimeCapability()
   const maintenance = maintenanceLifecycle.snapshot()
   const tts_local = getLocalTtsHealth()
@@ -180,6 +185,23 @@ healthRouter.get('/health', async (_req, res) => {
   // Whisper-server health + cloud budget — exposed so glasses + dashboards can
   // see whether we're at risk of falling to cloud and how much budget remains.
   const whisper_health = getWhisperHealth()
+  const whisperReadiness = !whisper_health.serverConfigured
+    ? 'not_configured'
+    : whisper_health.server
+      ? 'ready'
+      : whisper_health.startupState === 'preflight' || whisper_health.startupState === 'loading'
+        ? 'starting'
+        : 'degraded'
+  const readiness = {
+    // /api/health remains a liveness endpoint and intentionally returns HTTP
+    // 200 while the server can answer. This separate field prevents an HTTP-
+    // green response from hiding a configured local subsystem failure.
+    status: whisperReadiness === 'degraded' ? 'degraded' : 'ready',
+    admissions: maintenance.admissionsOpen ? 'open' : 'maintenance',
+    whisper: whisperReadiness,
+    whisperError: whisper_health.lastError,
+    localTts: tts_local.ready ? 'ready' : 'unavailable',
+  }
   const openai_whisper_budget = getOpenAIWhisperBudgetState()
   const codex_models = getCodexModelCatalogSnapshot()
   res.json({
@@ -190,12 +212,13 @@ healthRouter.get('/health', async (_req, res) => {
     generation_id: getServerGenerationId(),
     features,
     voice,
+    readiness,
     whisper_health,
     openai_whisper_budget,
     tts_local,
     codex_models,
     capabilities: {
-      transcription,
+      transcription: { ...transcription, hq: transcriptionHq },
       recovery,
       maintenance: {
         state: maintenance.state,
@@ -224,6 +247,7 @@ healthRouter.get('/models', async (req, res) => {
   const durableJobs = durableQueryJobStatus()
   const localFirstMeetings = localFirstMeetingsCapability(getServerInstanceId())
   const transcription = getTranscriptionPolicySnapshot()
+  const transcriptionHq = getHighQualityTranscriptionCapability()
   res.json({
     ...catalog,
     serverInstanceId: getServerInstanceId(),
@@ -232,7 +256,7 @@ healthRouter.get('/models', async (req, res) => {
         enabled: durableJobs.enabled,
         protocolVersion: durableJobs.protocolVersion,
       },
-      transcription,
+      transcription: { ...transcription, hq: transcriptionHq },
       cliDebug: CLI_DEBUG_CAPABILITY,
       recovery: managedRuntimeCapability(),
       ...(localFirstMeetings ? { localFirstMeetings } : {}),

package/server/routes/openai-compat.ts

@@ -295,6 +295,21 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
   void inflightPromise.catch(() => { /* duplicate waiters observe the original rejection */ })
   inflightQueries.set(dedupKey, { promise: inflightPromise, timestamp: Date.now() })
 
+  // Register disconnect cancellation before the provider starts. G2 can abort
+  // its first fetch while Claude/Codex continues running; without this signal
+  // the provider and its maintenance lease can strand a Control restart for
+  // the full model timeout. The lease is released only after the bridge reaches
+  // its terminal callback/catch, never merely because the socket disappeared.
+  const providerAbort = new AbortController()
+  let responseFinished = false
+  let clientDisconnected = false
+  res.once('finish', () => { responseFinished = true })
+  res.once('close', () => {
+    if (responseFinished) return
+    clientDisconnected = true
+    providerAbort.abort(new Error('G2 client disconnected'))
+  })
+
   // ── Streaming response (SSE) ──
   if (stream) {
     res.writeHead(200, {
@@ -326,7 +341,7 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
     try {
       const returnedSid = await callModelStreaming(query, currentSessionId, {
         onChunk: (text) => {
-          if (!done) {
+          if (!done && !clientDisconnected) {
             if (!firstChunkLogged) {
               firstChunkLogged = true
               actualTtfbMs = Date.now() - requestReceivedAt
@@ -360,16 +375,18 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
               stream_requested: true,
               })
               // Final chunk with finish_reason
-              const finalChunk = {
-              id: completionId,
-              object: 'chat.completion.chunk',
-              created: timestamp,
-              model: responseModel,
-              choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+              if (!clientDisconnected) {
+                const finalChunk = {
+                  id: completionId,
+                  object: 'chat.completion.chunk',
+                  created: timestamp,
+                  model: responseModel,
+                  choices: [{ index: 0, delta: {}, finish_reason: 'stop' }],
+                }
+                res.write(`data: ${JSON.stringify(finalChunk)}\n\n`)
+                res.write('data: [DONE]\n\n')
+                res.end()
               }
-              res.write(`data: ${JSON.stringify(finalChunk)}\n\n`)
-              res.write('data: [DONE]\n\n')
-              res.end()
             }
           } finally {
             maintenanceLease.release()
@@ -381,29 +398,34 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
               done = true
               rejectInflight!(new Error(error))
               inflightQueries.delete(dedupKey)
-              const errChunk = {
-              id: completionId,
-              object: 'chat.completion.chunk',
-              created: timestamp,
-              model: responseModel,
-              choices: [{ index: 0, delta: { content: `Error: ${error}` }, finish_reason: 'stop' }],
+              if (!clientDisconnected) {
+                const errChunk = {
+                  id: completionId,
+                  object: 'chat.completion.chunk',
+                  created: timestamp,
+                  model: responseModel,
+                  choices: [{ index: 0, delta: { content: `Error: ${error}` }, finish_reason: 'stop' }],
+                }
+                res.write(`data: ${JSON.stringify(errChunk)}\n\n`)
+                res.write('data: [DONE]\n\n')
+                res.end()
               }
-              res.write(`data: ${JSON.stringify(errChunk)}\n\n`)
-              res.write('data: [DONE]\n\n')
-              res.end()
             }
           } finally {
             maintenanceLease.release()
           }
         },
         onToolStatus: (status) => {
-          if (!done) {
+          if (!done && !clientDisconnected) {
             // SSE comment — invisible to JSON parsers but keeps connection alive
             res.write(`: ${status}\n\n`)
           }
         },
         onStart: () => {},
-      }, resolvedModel, undefined, undefined, undefined, { lightweight: true })
+      }, resolvedModel, undefined, undefined, undefined, {
+        lightweight: true,
+        abortSignal: providerAbort.signal,
+      })
       // Persist session ID for multi-turn context on subsequent G2 queries
       g2SessionId = returnedSid
     } catch (err: any) {
@@ -412,13 +434,13 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
         done = true
         rejectInflight!(err)
         inflightQueries.delete(dedupKey)
-        res.write(`data: ${JSON.stringify({ error: { message: err.message } })}\n\n`)
-        res.write('data: [DONE]\n\n')
-        res.end()
+        if (!clientDisconnected) {
+          res.write(`data: ${JSON.stringify({ error: { message: err.message } })}\n\n`)
+          res.write('data: [DONE]\n\n')
+          res.end()
+        }
       }
     }
-
-    req.on('close', () => { done = true })
     return
   }
 
@@ -479,11 +501,15 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
         },
         onToolStatus: () => {},
         onStart: () => {},
-      }, resolvedModel, undefined, undefined, undefined, { lightweight: true })
+      }, resolvedModel, undefined, undefined, undefined, {
+        lightweight: true,
+        abortSignal: providerAbort.signal,
+      })
         .then(sid => { g2SessionId = sid })
         .catch(fail)
     })
 
+    if (clientDisconnected) return
     res.json({
       id: completionId,
       object: 'chat.completion',
@@ -497,6 +523,7 @@ openaiCompatRouter.post('/v1/chat/completions', async (req, res) => {
       usage: { prompt_tokens: 0, completion_tokens: 0, total_tokens: 0 },
     })
   } catch (err: any) {
+    if (clientDisconnected) return
     res.status(500).json({
       error: { message: err.message, type: 'server_error' },
     })