@gotcos/glasses-server 6.15.3 → 6.15.5

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' },
     })

package/server/routes/prompt-drafts.ts

@@ -52,9 +52,18 @@ export const promptDraftsRouter = Router()
 const MAX_CHUNK_BYTES = 25 * 1024 * 1024
 const MAX_DRAFT_BYTES = 256 * 1024 * 1024
 const MAX_CHUNKS = 600
+/** Purpose-scoped keys (legacy). Prefer modeQualityJobs for HQ warm↔finalize dedupe. */
 const chunkTranscriptJobs = new Map<string, Promise<string>>()
+/** Shared decode per draft/chunk/mode/hash — warm:hq and final:hq await the same promise. */
+const modeQualityJobs = new Map<string, Promise<string>>()
 const finalizeJobs = new Map<string, Promise<any>>()
 let warmTail: Promise<void> = Promise.resolve()
+let hqWarmTail: Promise<void> = Promise.resolve()
+
+/** Speculative HQ warm while speaking. Set COS_HQ_SPECULATIVE_WARM=0 to restore Fast-only warm. */
+function speculativeHqWarmEnabled(): boolean {
+  return !['0', 'false', 'off'].includes((process.env.COS_HQ_SPECULATIVE_WARM ?? '1').toLowerCase())
+}
 
 const autoCleanBreaker = createBreaker({ label: 'dictation-autoclean' })
 const autoCleanCountFile = () => process.env.COS_DICTATION_AUTOCLEAN_COUNT_FILE || dataPath('.dictation_autoclean_count.json')
@@ -164,14 +173,49 @@ async function sendDraftError(res: Response, draftId: string, err: any): Promise
   res.status(err.status ?? 500).json({ error: err.message })
 }
 
+function modeQualityKey(draftId: string, chunkIndex: number, mode: 'hq' | 'fast', hash: string): string {
+  return `${draftId}:${chunkIndex}:${mode}:${hash}`
+}
+
 async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffer, mode: 'hq' | 'fast', purpose: 'warm' | 'final'): Promise<string> {
   const hash = audioHash(audio)
-  const key = `${draftId}:${chunkIndex}:${purpose}:${mode}:${hash}`
-  const existing = chunkTranscriptJobs.get(key)
+  const purposeKey = `${draftId}:${chunkIndex}:${purpose}:${mode}:${hash}`
+  const sharedKey = modeQualityKey(draftId, chunkIndex, mode, hash)
+
+  // HQ warm and HQ finalize must share one decode (plan step 8a).
+  const existingShared = modeQualityJobs.get(sharedKey)
+  if (existingShared) {
+    try {
+      const text = await existingShared
+      if (purpose === 'final' && text) {
+        const current = loadPromptDraftMeta(draftId)
+        const warm = current?.warmTranscripts?.[String(chunkIndex)]
+        const cachedFinal = current?.finalTranscripts?.[String(chunkIndex)]
+        if (!cachedFinal || cachedFinal.hash !== hash) {
+          await markPromptDraftChunkTranscript(draftId, chunkIndex, {
+            text,
+            hash,
+            requestedMode: warm?.requestedMode ?? mode,
+            actualQuality: warm?.actualQuality ?? (mode === 'hq' ? 'hq' : 'fast'),
+            backend: warm?.backend ?? 'shared-inflight',
+            degraded: warm?.degraded ?? false,
+          }, 'final')
+        }
+      }
+      return text
+    } catch {
+      // Shared warm failed under local-only; fall through so finalize can retry with automatic.
+    }
+  }
+
+  const existing = chunkTranscriptJobs.get(purposeKey)
   if (existing) return existing
+
   const job = (async () => {
     try {
-      const result = await transcribeAudioBuffer(audio, { mode, policy: purpose === 'warm' ? 'local-only' : 'automatic' })
+      // Speculative warm is always local-only. Finalize may use automatic cloud fallback.
+      const policy = purpose === 'warm' ? 'local-only' as const : 'automatic' as const
+      const result = await transcribeAudioBuffer(audio, { mode, policy })
       if (!isCurrentChunk(draftId, chunkIndex, audio)) return ''
       const text = sanitizeTranscript(draftId, result.text)
       const record: PromptDraftTranscriptRecord = {
@@ -179,7 +223,7 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
         backend: result.backend, degraded: result.degraded,
       }
       await markPromptDraftChunkTranscript(draftId, chunkIndex, record, purpose)
-      console.log(`[prompt-draft] chunk ${draftId}/${chunkIndex}: ${result.elapsedMs.toFixed(1)}ms | ${result.backend} | ${text.length} chars`)
+      console.log(`[prompt-draft] chunk ${draftId}/${chunkIndex}: ${result.elapsedMs.toFixed(1)}ms | ${result.backend} | ${purpose}/${mode} | ${text.length} chars`)
       return text
     } catch (err) {
       if (err instanceof NoSpeechDetectedError) {
@@ -190,10 +234,12 @@ async function transcribeChunk(draftId: string, chunkIndex: number, audio: Buffe
       }
       throw err
     } finally {
-      chunkTranscriptJobs.delete(key)
+      chunkTranscriptJobs.delete(purposeKey)
+      modeQualityJobs.delete(sharedKey)
     }
   })()
-  chunkTranscriptJobs.set(key, job)
+  chunkTranscriptJobs.set(purposeKey, job)
+  modeQualityJobs.set(sharedKey, job)
   return job
 }
 
@@ -203,9 +249,17 @@ async function finalizeDraft(draftId: string, mode: 'hq' | 'fast', autoClean: Au
   const texts: string[] = []
   for (const chunk of readPromptDraftChunks(draftId)) {
     try {
+      const hash = audioHash(chunk.audioBuffer)
+      // Await in-flight HQ warm before deciding cache miss (plan step 8b belt).
+      if (mode === 'hq') {
+        const inflight = modeQualityJobs.get(modeQualityKey(draftId, chunk.chunkIndex, 'hq', hash))
+        if (inflight) {
+          try { await inflight } catch { /* finalize may retry with automatic below */ }
+        }
+      }
       const current = loadPromptDraftMeta(draftId)
       const cached = current?.finalTranscripts?.[String(chunk.chunkIndex)] ?? current?.warmTranscripts?.[String(chunk.chunkIndex)]
-      const reusable = Boolean(cached && cached.hash === audioHash(chunk.audioBuffer) && (mode === 'fast' ? cached.actualQuality === 'fast' : cached.actualQuality === 'hq'))
+      const reusable = Boolean(cached && cached.hash === hash && (mode === 'fast' ? cached.actualQuality === 'fast' : cached.actualQuality === 'hq'))
       const raw = reusable ? cached!.text : await transcribeChunk(draftId, chunk.chunkIndex, chunk.audioBuffer, mode, 'final')
       const text = sanitizeTranscript(draftId, raw, !reusable)
       if (text.trim()) texts.push(text.trim())
@@ -265,10 +319,13 @@ promptDraftsRouter.post('/prompt-drafts/:draftId/chunks', async (req, res) => {
     const nextTotal = Object.values(before.chunkBytes).reduce((sum, bytes) => sum + bytes, 0) - existingBytes + audio.length
     if (nextTotal > MAX_DRAFT_BYTES) return res.status(413).json({ error: 'prompt draft too large' })
     const meta = await savePromptDraftChunk(req.params.draftId, chunkIndex, audio)
+    const requestedMode = routeMode(req)
     const warmLease = acquireMaintenanceWork('prompt_draft_warm', {
       allowDuringDrain: true,
       phase: 'queued',
     })
+    // Fast warm feeds the live HUD. Speculative HQ (when Settings HQ / default)
+    // overwrites warmTranscripts with actualQuality=hq for near-instant finalize.
     warmTail = warmTail.then(async () => {
       warmLease.setPhase('active')
       const text = await transcribeChunk(req.params.draftId, chunkIndex, audio, 'fast', 'warm')
@@ -283,6 +340,21 @@ promptDraftsRouter.post('/prompt-drafts/:draftId/chunks', async (req, res) => {
     }).catch(err => {
       console.warn(`[prompt-draft] warm transcription failed ${req.params.draftId}/${chunkIndex}: ${err.message}`)
     }).finally(() => warmLease.release())
+
+    if (requestedMode === 'hq' && speculativeHqWarmEnabled()) {
+      const hqLease = acquireMaintenanceWork('prompt_draft_warm', {
+        allowDuringDrain: true,
+        phase: 'queued',
+      })
+      hqWarmTail = hqWarmTail.then(async () => {
+        hqLease.setPhase('active')
+        // Cache only — never emitDisplay HQ (avoids HUD flicker). local-only via purpose=warm.
+        await transcribeChunk(req.params.draftId, chunkIndex, audio, 'hq', 'warm')
+      }).catch(err => {
+        console.warn(`[prompt-draft] speculative HQ warm failed ${req.params.draftId}/${chunkIndex}: ${err.message}`)
+      }).finally(() => hqLease.release())
+    }
+
     res.json({ draftId: meta.draftId, chunkIndex, acked: true, receivedChunkIndexes: meta.receivedChunkIndexes, chunkBytes: meta.chunkBytes[String(chunkIndex)] ?? audio.length, transcriptPending: true, expiresAt: meta.expiresAt })
   } catch (err: any) {
     if (err instanceof MaintenanceLifecycleError) {

package/server/routes/provider-proof.ts

@@ -1,5 +1,11 @@
 import { Router } from 'express'
 import { runProviderProof, type ProofProvider } from '../lib/provider-proof.js'
+import {
+  acquireMaintenanceWork,
+  maintenanceErrorPayload,
+  maintenanceOperationCredentialsValid,
+  MaintenanceLifecycleError,
+} from '../lib/maintenance-lifecycle.js'
 
 export const providerProofRouter = Router()
 
@@ -14,6 +20,38 @@ providerProofRouter.post('/diagnostics/provider-proof', async (req, res) => {
   if (provider !== 'claude' && provider !== 'codex') {
     return res.status(400).json({ error: 'provider must be claude or codex' })
   }
-  const result = await runProviderProof(provider as ProofProvider)
-  return res.status(result.ok ? 200 : 503).json(result)
+  const controllerProof = maintenanceOperationCredentialsValid({
+    leaseId: typeof req.headers['x-cos-maintenance-lease'] === 'string'
+      ? req.headers['x-cos-maintenance-lease'] : undefined,
+    operationId: typeof req.headers['x-cos-maintenance-operation'] === 'string'
+      ? req.headers['x-cos-maintenance-operation'] : undefined,
+    nonce: typeof req.headers['x-cos-maintenance-nonce'] === 'string'
+      ? req.headers['x-cos-maintenance-nonce'] : undefined,
+  })
+  let lease
+  try {
+    lease = acquireMaintenanceWork('api_mutation', { allowDuringDrain: controllerProof })
+  } catch (error) {
+    if (error instanceof MaintenanceLifecycleError) {
+      if (error.retryAfterSeconds != null) res.setHeader('Retry-After', String(error.retryAfterSeconds))
+      return res.status(error.status).json(maintenanceErrorPayload(error))
+    }
+    return res.status(500).json({ error: 'maintenance_internal_error', retryable: false })
+  }
+
+  const abort = new AbortController()
+  let responseFinished = false
+  const cancel = () => { if (!responseFinished) abort.abort(new Error('Control proof client disconnected')) }
+  req.once('aborted', cancel)
+  res.once('finish', () => { responseFinished = true })
+  res.once('close', cancel)
+  try {
+    const result = await runProviderProof(provider as ProofProvider, abort.signal)
+    if (abort.signal.aborted) return
+    return res.status(result.ok ? 200 : 503).json(result)
+  } finally {
+    req.removeListener('aborted', cancel)
+    res.removeListener('close', cancel)
+    lease.release()
+  }
 })