@gotcos/glasses-server 6.38.0 → 6.39.0

package/server/lib/ollama-bridge.ts

@@ -0,0 +1,274 @@
+// Direct Ollama chat — POST /api/chat. No Codex --oss, no tools, text only.
+
+import type { CallOptions, StreamCallbacks } from './claude-bridge.js'
+import { buildLightweightSystemPrompt } from './context-builder.js'
+import {
+  addExchange,
+  formatHistoryForPrompt,
+  getHistory,
+  getOrCreateSession,
+  getSessionRaw,
+  isNewSession,
+  markSessionNotified,
+  reconcileExchangeByJobIdentity,
+  type Exchange,
+  type PromptReference,
+} from './conversation.js'
+import { cleanupModelImageInputs, type ModelImageInput } from './model-image-input.js'
+import {
+  getOllamaCatalog,
+  isOllamaProviderReady,
+  ollamaFetch,
+} from './ollama-catalog.js'
+import {
+  classifyOllamaError,
+  finishOllamaRun,
+  startOllamaRun,
+} from './ollama-run-ledger.js'
+import { notifyExchange, notifySessionStart } from './telegram-notify.js'
+import { OLLAMA_MODEL } from '../../shared/model-preference.js'
+
+const INACTIVITY_MS = 60_000
+const WALL_MAX_MS = 180_000
+const HISTORY_LIMIT = 20
+
+type OllamaChatMessage = { role: 'system' | 'user' | 'assistant'; content: string }
+
+export function parseOllamaChatDelta(line: string): { content: string; done: boolean; error?: string } {
+  const trimmed = line.trim()
+  if (!trimmed) return { content: '', done: false }
+  try {
+    const event = JSON.parse(trimmed) as {
+      error?: unknown
+      done?: unknown
+      message?: { content?: unknown }
+    }
+    if (typeof event.error === 'string' && event.error.trim()) {
+      return { content: '', done: true, error: event.error.trim() }
+    }
+    const content = typeof event.message?.content === 'string' ? event.message.content : ''
+    return { content, done: event.done === true }
+  } catch {
+    return { content: '', done: false }
+  }
+}
+
+export function historyToOllamaMessages(
+  exchanges: Exchange[],
+  contextBreaks: number[],
+  limit = HISTORY_LIMIT,
+): OllamaChatMessage[] {
+  const lastBreak = contextBreaks.length > 0 ? contextBreaks[contextBreaks.length - 1]! : 0
+  const recent = exchanges.filter(ex => ex.timestamp >= lastBreak).slice(-limit)
+  const messages: OllamaChatMessage[] = []
+  for (const ex of recent) {
+    const content = ex.content.trim()
+    if (!content) continue
+    if (ex.role === 'user') messages.push({ role: 'user', content })
+    else messages.push({ role: 'assistant', content })
+  }
+  return messages
+}
+
+function safeOllamaUserError(message: string): string {
+  const code = classifyOllamaError(message)
+  if (code === 'ollama.unavailable') return 'Ollama is not running. Start ollama serve on this Mac.'
+  if (code === 'ollama.no_model') return 'Ollama has no pulled models. Run ollama pull, then retry.'
+  if (code === 'ollama.text_only') return 'Ollama is text-only here. Remove the photo and retry.'
+  if (code === 'ollama.timeout') return 'Ollama timed out. Retry or pick another model.'
+  return `Ollama failed (${code}). Retry or check that ollama serve is running.`
+}
+
+export async function callOllamaStreaming(
+  query: string,
+  sessionId: string | undefined,
+  callbacks: StreamCallbacks,
+  images?: ModelImageInput[],
+  reference?: PromptReference,
+  globalMsgNum?: number,
+  options?: CallOptions,
+): Promise<string> {
+  const sid = getOrCreateSession(sessionId)
+  const imageInputs = images ?? []
+  const inboundAttachments = options?.requestAttachments ?? []
+
+  if (imageInputs.length > 0 || inboundAttachments.length > 0) {
+    cleanupModelImageInputs(imageInputs)
+    await callbacks.onError(safeOllamaUserError('ollama-bridge: Ollama is text-only in this version.'))
+    return sid
+  }
+
+  await getOllamaCatalog()
+  const catalog = await getOllamaCatalog()
+  if (!isOllamaProviderReady() || !catalog.model) {
+    await callbacks.onError(safeOllamaUserError(
+      catalog.error ? `ollama-bridge: ${catalog.error}` : 'ollama-bridge: Ollama is not ready.',
+    ))
+    return sid
+  }
+
+  const history = getHistory(sid)
+  const session = getSessionRaw(sid)
+  const contextBreaks = session?.contextBreaks ?? []
+  const historyPrompt = formatHistoryForPrompt(history, contextBreaks, reference)
+  const handoffPrompt = options?.handoffContext?.promptBlock ? `\n\n${options.handoffContext.promptBlock}` : ''
+  const systemPrompt = `${buildLightweightSystemPrompt(query, `${historyPrompt}${handoffPrompt}`)}\n\nYou have no tools. Answer from the prompt and conversation only. Plain text.`
+
+  const startTime = Date.now()
+  const run = startOllamaRun({
+    turnId: options?.turnId,
+    clientJobId: options?.clientJobId,
+    cosSessionId: sid,
+    ollamaModel: catalog.model,
+    origin: catalog.origin,
+    query,
+  })
+
+  callbacks.onStart?.(OLLAMA_MODEL, sid, undefined, { ollamaRunId: run.runId })
+  await callbacks.onProviderProcess?.({
+    provider: 'ollama',
+    runId: run.runId,
+    clientJobId: options?.clientJobId,
+    generation: options?.jobGeneration ?? options?.generation,
+  })
+
+  const jobGeneration = options?.jobGeneration ?? options?.generation
+  const durableIdentity = options?.clientJobId && Number.isSafeInteger(jobGeneration) && jobGeneration! > 0
+    ? { clientJobId: options.clientJobId, generation: jobGeneration! } : undefined
+  if (durableIdentity) {
+    reconcileExchangeByJobIdentity(sid, durableIdentity, 'user', query, globalMsgNum, undefined, undefined, OLLAMA_MODEL)
+  } else {
+    addExchange(sid, 'user', query, globalMsgNum, undefined, durableIdentity, OLLAMA_MODEL)
+  }
+
+  if (isNewSession(sid)) {
+    notifySessionStart(sid, query)
+    markSessionNotified(sid)
+  }
+
+  const messages: OllamaChatMessage[] = [
+    { role: 'system', content: systemPrompt },
+    ...historyToOllamaMessages(history, contextBreaks),
+    { role: 'user', content: query },
+  ]
+
+  const abort = new AbortController()
+  const onExternalAbort = () => abort.abort()
+  options?.abortSignal?.addEventListener('abort', onExternalAbort, { once: true })
+
+  let inactivityTimer: ReturnType<typeof setTimeout> | undefined
+  let wallTimer: ReturnType<typeof setTimeout> | undefined
+  const clearTimers = () => {
+    if (inactivityTimer) clearTimeout(inactivityTimer)
+    if (wallTimer) clearTimeout(wallTimer)
+  }
+  const bumpInactivity = () => {
+    if (inactivityTimer) clearTimeout(inactivityTimer)
+    inactivityTimer = setTimeout(() => abort.abort(), INACTIVITY_MS)
+  }
+
+  let fullText = ''
+  let finalized = false
+  const finalizeError = async (raw: string) => {
+    if (finalized) return
+    finalized = true
+    clearTimers()
+    finishOllamaRun(run.runId, { status: 'failed', startedAtMs: startTime, error: raw })
+    await callbacks.onError(safeOllamaUserError(raw))
+  }
+  const finalizeDone = async () => {
+    if (finalized) return
+    finalized = true
+    clearTimers()
+    const text = fullText.trim()
+    if (!text) {
+      finishOllamaRun(run.runId, { status: 'failed', startedAtMs: startTime, error: 'ollama-bridge: empty response' })
+      await callbacks.onError(safeOllamaUserError('ollama-bridge: Ollama completed without a response.'))
+      return
+    }
+    if (durableIdentity) {
+      reconcileExchangeByJobIdentity(sid, durableIdentity, 'assistant', text, globalMsgNum, undefined, undefined, OLLAMA_MODEL)
+    } else {
+      addExchange(sid, 'assistant', text, globalMsgNum, undefined, durableIdentity, OLLAMA_MODEL)
+    }
+    finishOllamaRun(run.runId, { status: 'completed', startedAtMs: startTime, output: text })
+    notifyExchange(sid, query, text)
+    await callbacks.onDone(text, OLLAMA_MODEL, undefined, { ollamaRunId: run.runId })
+  }
+
+  bumpInactivity()
+  wallTimer = setTimeout(() => abort.abort(), WALL_MAX_MS)
+
+  try {
+    const response = await ollamaFetch(`${catalog.origin}/api/chat`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        model: catalog.model,
+        messages,
+        stream: true,
+      }),
+      signal: abort.signal,
+    })
+    if (!response.ok) {
+      const detail = (await response.text().catch(() => '')).trim().slice(0, 240)
+      await finalizeError(`ollama-bridge: HTTP ${response.status}${detail ? ` — ${detail}` : ''}`)
+      return sid
+    }
+    if (!response.body) {
+      await finalizeError('ollama-bridge: empty stream')
+      return sid
+    }
+
+    const reader = response.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+      bumpInactivity()
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split('\n')
+      buffer = lines.pop() ?? ''
+      for (const line of lines) {
+        const delta = parseOllamaChatDelta(line)
+        if (delta.error) {
+          await finalizeError(`ollama-bridge: ${delta.error}`)
+          return sid
+        }
+        if (delta.content) {
+          fullText += delta.content
+          callbacks.onChunk(delta.content)
+        }
+        if (delta.done) {
+          await finalizeDone()
+          return sid
+        }
+      }
+    }
+    if (buffer.trim()) {
+      const delta = parseOllamaChatDelta(buffer)
+      if (delta.error) {
+        await finalizeError(`ollama-bridge: ${delta.error}`)
+        return sid
+      }
+      if (delta.content) {
+        fullText += delta.content
+        callbacks.onChunk(delta.content)
+      }
+    }
+    await finalizeDone()
+    return sid
+  } catch (error: any) {
+    const aborted = abort.signal.aborted || options?.abortSignal?.aborted
+    await finalizeError(
+      aborted
+        ? 'ollama-bridge: request aborted'
+        : `ollama-bridge: ${error?.message ?? 'fetch failed'}`,
+    )
+    return sid
+  } finally {
+    clearTimers()
+    options?.abortSignal?.removeEventListener('abort', onExternalAbort)
+  }
+}

package/server/lib/ollama-catalog.ts

@@ -0,0 +1,161 @@
+// Local Ollama discovery. Hidden picker until GET /api/tags succeeds with a model.
+// Host is loopback-only — COS_OLLAMA_HOST that is not 127.0.0.1 / localhost / ::1
+// is refused (SSRF).
+
+export const DEFAULT_OLLAMA_ORIGIN = 'http://127.0.0.1:11434'
+const PROBE_TIMEOUT_MS = 2_000
+const CACHE_TTL_MS = 30_000
+
+export interface OllamaCatalog {
+  ready: boolean
+  origin: string
+  model: string
+  models: string[]
+  refreshedAt: string
+  error?: string
+}
+
+type FetchLike = typeof fetch
+let catalogFetch: FetchLike = globalThis.fetch.bind(globalThis)
+
+export function ollamaFetch(...args: Parameters<FetchLike>): ReturnType<FetchLike> {
+  return catalogFetch(...args)
+}
+
+export function _setOllamaCatalogFetchForTests(fn: FetchLike | null): void {
+  catalogFetch = fn ?? globalThis.fetch.bind(globalThis)
+}
+
+function unavailableCatalog(origin: string, error: string): OllamaCatalog {
+  return {
+    ready: false,
+    origin,
+    model: '',
+    models: [],
+    refreshedAt: new Date().toISOString(),
+    error,
+  }
+}
+
+export function isLoopbackHostname(hostname: string): boolean {
+  const host = hostname.replace(/^\[|\]$/g, '').toLowerCase()
+  return host === 'localhost' || host === '127.0.0.1' || host === '::1'
+}
+
+export function resolveOllamaOrigin(
+  raw: string | undefined = process.env.COS_OLLAMA_HOST,
+): { ok: true; origin: string } | { ok: false; error: string } {
+  const trimmed = (raw ?? '').trim()
+  if (!trimmed) return { ok: true, origin: DEFAULT_OLLAMA_ORIGIN }
+  try {
+    const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(trimmed) ? trimmed : `http://${trimmed}`
+    const url = new URL(withScheme)
+    if (url.protocol !== 'http:' && url.protocol !== 'https:') {
+      return { ok: false, error: 'COS_OLLAMA_HOST must be http(s) on loopback' }
+    }
+    if (!isLoopbackHostname(url.hostname)) {
+      return { ok: false, error: 'COS_OLLAMA_HOST must be loopback (127.0.0.1, localhost, ::1)' }
+    }
+    if (url.username || url.password) {
+      return { ok: false, error: 'COS_OLLAMA_HOST must not include credentials' }
+    }
+    return { ok: true, origin: url.origin }
+  } catch {
+    return { ok: false, error: 'COS_OLLAMA_HOST is not a valid URL' }
+  }
+}
+
+export function selectOllamaModel(names: string[], preferred?: string): string {
+  const cleaned = names.map(name => name.trim()).filter(Boolean)
+  if (cleaned.length === 0) return ''
+  const pin = (preferred ?? process.env.COS_OLLAMA_MODEL ?? '').trim()
+  if (!pin) return cleaned[0] ?? ''
+  if (cleaned.includes(pin)) return pin
+  const tagged = cleaned.find(name => name.startsWith(`${pin}:`))
+  return tagged ?? ''
+}
+
+export function parseOllamaTagNames(body: unknown): string[] {
+  if (!body || typeof body !== 'object') return []
+  const models = (body as { models?: unknown }).models
+  if (!Array.isArray(models)) return []
+  const names: string[] = []
+  for (const row of models) {
+    if (!row || typeof row !== 'object') continue
+    const record = row as { name?: unknown; model?: unknown }
+    const name = typeof record.name === 'string' ? record.name
+      : typeof record.model === 'string' ? record.model
+        : ''
+    if (name.trim()) names.push(name.trim())
+  }
+  return names
+}
+
+let catalogSnapshot: OllamaCatalog = unavailableCatalog(DEFAULT_OLLAMA_ORIGIN, 'unprobed')
+let refreshPromise: Promise<OllamaCatalog> | null = null
+
+export function getOllamaCatalogSnapshot(): OllamaCatalog {
+  return catalogSnapshot
+}
+
+export function isOllamaProviderReady(): boolean {
+  return catalogSnapshot.ready && catalogSnapshot.model.length > 0
+}
+
+export function _resetOllamaCatalogCache(): void {
+  catalogSnapshot = unavailableCatalog(DEFAULT_OLLAMA_ORIGIN, 'unprobed')
+  refreshPromise = null
+}
+
+async function probeOllamaCatalog(): Promise<OllamaCatalog> {
+  const originResult = resolveOllamaOrigin()
+  if (!originResult.ok) return unavailableCatalog(DEFAULT_OLLAMA_ORIGIN, originResult.error)
+  const origin = originResult.origin
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), PROBE_TIMEOUT_MS)
+  try {
+    const response = await catalogFetch(`${origin}/api/tags`, { signal: controller.signal })
+    if (!response.ok) {
+      return unavailableCatalog(origin, `ollama /api/tags HTTP ${response.status}`)
+    }
+    const body = await response.json() as unknown
+    const models = parseOllamaTagNames(body)
+    const model = selectOllamaModel(models)
+    if (!model) return unavailableCatalog(origin, 'no models pulled')
+    return {
+      ready: true,
+      origin,
+      model,
+      models,
+      refreshedAt: new Date().toISOString(),
+    }
+  } catch (error: any) {
+    const message = error?.name === 'AbortError'
+      ? 'ollama probe timed out'
+      : (error?.message ? String(error.message).slice(0, 160) : 'ollama unreachable')
+    return unavailableCatalog(origin, message)
+  } finally {
+    clearTimeout(timer)
+  }
+}
+
+export async function getOllamaCatalog(forceRefresh = false): Promise<OllamaCatalog> {
+  const ageMs = Date.now() - Date.parse(catalogSnapshot.refreshedAt)
+  if (
+    !forceRefresh
+    && catalogSnapshot.ready
+    && Number.isFinite(ageMs)
+    && ageMs >= 0
+    && ageMs < CACHE_TTL_MS
+  ) {
+    return catalogSnapshot
+  }
+  if (refreshPromise) return refreshPromise
+  refreshPromise = probeOllamaCatalog().then(snapshot => {
+    catalogSnapshot = snapshot
+    return snapshot
+  }).finally(() => {
+    refreshPromise = null
+  })
+  return refreshPromise
+}

package/server/lib/ollama-run-ledger.ts

@@ -0,0 +1,178 @@
+import crypto from 'node:crypto'
+import { appendFileSync, existsSync, mkdirSync, readFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+import { OLLAMA_MODEL, type OllamaModelPreference } from '../../shared/model-preference.js'
+
+const DEFAULT_MAX_RUNS = 100
+const DEFAULT_TTL_MS = 7 * 24 * 60 * 60_000
+const ERROR_PREVIEW_CHARS = 160
+const RUNNING_STALE_MS = 30 * 60_000
+
+export type OllamaRunStatus = 'running' | 'completed' | 'failed' | 'cancelled' | 'client_disconnected'
+
+export interface OllamaRunRecord {
+  runId: string
+  turnId?: string
+  clientJobId?: string
+  cosSessionId: string
+  status: OllamaRunStatus
+  createdAt: string
+  updatedAt: string
+  model: OllamaModelPreference
+  ollamaModel: string
+  origin: string
+  queryPreview?: string
+  outputPreview?: string
+  errorCode?: string
+  errorPreview?: string
+  durationMs?: number
+}
+
+interface OllamaRunEvent {
+  runId: string
+  ts: string
+  patch: Partial<OllamaRunRecord>
+}
+
+function getProcessStartedAtMs(): number {
+  return Date.now() - Math.floor(process.uptime() * 1000)
+}
+
+export function getOllamaLedgerPath(): string {
+  return resolve(process.env.COS_OLLAMA_RUN_LEDGER_FILE || resolve(import.meta.dirname, '..', 'data', 'ollama-runs.jsonl'))
+}
+
+function getMaxRuns(): number {
+  const raw = Number(process.env.COS_OLLAMA_RUN_LEDGER_MAX ?? DEFAULT_MAX_RUNS)
+  return Number.isFinite(raw) && raw > 0 ? Math.floor(raw) : DEFAULT_MAX_RUNS
+}
+
+function getTtlMs(): number {
+  const rawDays = Number(process.env.COS_OLLAMA_RUN_LEDGER_TTL_DAYS ?? 7)
+  return Number.isFinite(rawDays) && rawDays > 0 ? rawDays * 24 * 60 * 60_000 : DEFAULT_TTL_MS
+}
+
+function appendEvent(event: OllamaRunEvent): void {
+  try {
+    const path = getOllamaLedgerPath()
+    mkdirSync(dirname(path), { recursive: true })
+    appendFileSync(path, JSON.stringify(event) + '\n')
+  } catch (err) {
+    console.warn('[ollama-run-ledger] write skipped:', err)
+  }
+}
+
+function readEvents(): OllamaRunEvent[] {
+  const path = getOllamaLedgerPath()
+  if (!existsSync(path)) return []
+  try {
+    const events: OllamaRunEvent[] = []
+    for (const line of readFileSync(path, 'utf-8').split('\n').map(row => row.trim()).filter(Boolean)) {
+      try {
+        const event = JSON.parse(line) as OllamaRunEvent
+        if (typeof event.runId === 'string' && typeof event.ts === 'string' && typeof event.patch === 'object') {
+          events.push(event)
+        }
+      } catch {
+        // Skip torn JSONL rows.
+      }
+    }
+    return events
+  } catch {
+    return []
+  }
+}
+
+export function redactForOllamaLedger(value: string, maxChars = ERROR_PREVIEW_CHARS): string {
+  return value.replace(/\s+/g, ' ').trim().slice(0, maxChars)
+}
+
+export function classifyOllamaError(message: string): string {
+  const text = message.toLowerCase()
+  if (/unreachable|econnrefused|fetch failed|enotfound/.test(text)) return 'ollama.unavailable'
+  if (/no models|not ready/.test(text)) return 'ollama.no_model'
+  if (/text-only|photo|image/.test(text)) return 'ollama.text_only'
+  if (/timeout|timed out|aborted/.test(text)) return 'ollama.timeout'
+  return 'ollama.error'
+}
+
+export function startOllamaRun(input: {
+  turnId?: string
+  clientJobId?: string
+  cosSessionId: string
+  ollamaModel: string
+  origin: string
+  query: string
+}): OllamaRunRecord {
+  const now = new Date().toISOString()
+  const run: OllamaRunRecord = {
+    runId: `ollama-${crypto.randomUUID().slice(0, 8)}`,
+    turnId: input.turnId,
+    clientJobId: input.clientJobId,
+    cosSessionId: input.cosSessionId,
+    status: 'running',
+    createdAt: now,
+    updatedAt: now,
+    model: OLLAMA_MODEL,
+    ollamaModel: input.ollamaModel,
+    origin: input.origin,
+    queryPreview: redactForOllamaLedger(input.query),
+  }
+  appendEvent({ runId: run.runId, ts: now, patch: run })
+  return run
+}
+
+export function finishOllamaRun(runId: string, input: {
+  status: Exclude<OllamaRunStatus, 'running'>
+  startedAtMs: number
+  output?: string
+  error?: string
+}): OllamaRunRecord | null {
+  const patch: Partial<OllamaRunRecord> = {
+    status: input.status,
+    durationMs: Math.max(0, Date.now() - input.startedAtMs),
+  }
+  if (input.output) patch.outputPreview = redactForOllamaLedger(input.output)
+  if (input.error) {
+    patch.errorCode = classifyOllamaError(input.error)
+    patch.errorPreview = redactForOllamaLedger(input.error)
+  }
+  const ts = new Date().toISOString()
+  appendEvent({ runId, ts, patch: { ...patch, updatedAt: ts } })
+  return getOllamaRun(runId)
+}
+
+export function getOllamaRun(runId: string): OllamaRunRecord | null {
+  return listOllamaRuns(getMaxRuns()).find(run => run.runId === runId) ?? null
+}
+
+export function listOllamaRuns(limit = 20, sessionId?: string): OllamaRunRecord[] {
+  const runs = new Map<string, OllamaRunRecord>()
+  const order = new Map<string, number>()
+  let eventIndex = 0
+  for (const event of readEvents()) {
+    eventIndex += 1
+    const existing = runs.get(event.runId)
+    const next = { ...(existing ?? {}), ...event.patch, runId: event.runId } as OllamaRunRecord
+    runs.set(event.runId, next)
+    order.set(event.runId, eventIndex)
+  }
+  const cutoff = Date.now() - getTtlMs()
+  return Array.from(runs.values())
+    .filter(run => run.createdAt && Date.parse(run.updatedAt || run.createdAt) >= cutoff)
+    .filter(run => !sessionId || run.cosSessionId === sessionId)
+    .map(run => {
+      const updatedMs = Date.parse(run.updatedAt || run.createdAt)
+      const predatesCurrentProcess = updatedMs < getProcessStartedAtMs() - 1000
+      if (run.status === 'running' && (predatesCurrentProcess || Date.now() - updatedMs > RUNNING_STALE_MS)) {
+        return {
+          ...run,
+          status: 'client_disconnected' as const,
+          errorCode: run.errorCode ?? 'ollama.timeout',
+        }
+      }
+      return run
+    })
+    .sort((a, b) => Date.parse(b.createdAt) - Date.parse(a.createdAt))
+    .slice(0, limit)
+}

package/server/lib/query-job-runtime.ts

@@ -13,6 +13,7 @@ import { QueryJobStore } from './query-job-store.js'
 import {
   isCodexModel,
   isCursorModel,
+  isOllamaModel,
   normalizeEffortPreference,
   normalizeModelPreference,
   type CursorExecutionMode,
@@ -101,7 +102,8 @@ export async function preparePublicDurableQueryAdmission(raw: unknown): Promise<
   }
 }
 
-function providerFor(model: ModelPreference): 'claude' | 'codex' | 'cursor' {
+function providerFor(model: ModelPreference): 'claude' | 'codex' | 'cursor' | 'ollama' {
+  if (isOllamaModel(model)) return 'ollama'
   if (isCursorModel(model)) return 'cursor'
   return isCodexModel(model) ? 'codex' : 'claude'
 }
@@ -183,6 +185,7 @@ const runner: QueryJobRunner = async ({ jobId, turnId, request, signal, callback
           codexRunId: metadata?.codexRunId,
           codexThreadId: metadata?.codexThreadId,
           cursorRunId: metadata?.cursorRunId,
+          ollamaRunId: metadata?.ollamaRunId,
         } as const
         await callbacks.onStart({ sessionId, ...linkage })
         emitDisplay({ type: 'start', data: {
@@ -205,7 +208,9 @@ const runner: QueryJobRunner = async ({ jobId, turnId, request, signal, callback
           ? { claudeRunId: metadata.runId }
           : metadata.provider === 'cursor'
             ? { cursorRunId: metadata.runId }
-            : { codexRunId: metadata.runId }),
+            : metadata.provider === 'ollama'
+              ? { ollamaRunId: metadata.runId }
+              : { codexRunId: metadata.runId }),
       }),
       onChunk: text => { callbacks.onChunk(text) },
       onToolStatus: toolName => {
@@ -239,6 +244,7 @@ const runner: QueryJobRunner = async ({ jobId, turnId, request, signal, callback
           codexRunId: metadata?.codexRunId,
           codexThreadId: metadata?.codexThreadId,
           cursorRunId: metadata?.cursorRunId,
+          ollamaRunId: metadata?.ollamaRunId,
         } as const
         // Publish compatibility completion only after the durable terminal is
         // fsynced. Display subscribers can disappear without owning this job.

package/server/lib/query-job-types.ts

@@ -75,13 +75,14 @@ export interface QueryJobRequest {
 }
 
 export interface QueryJobProviderLinkage {
-  provider?: 'claude' | 'codex' | 'cursor'
+  provider?: 'claude' | 'codex' | 'cursor' | 'ollama'
   resolvedModel?: string
   cliSessionId?: string
   claudeRunId?: string
   codexRunId?: string
   codexThreadId?: string
   cursorRunId?: string
+  ollamaRunId?: string
 }
 
 /** Path/id-free aggregate from output-image finalization. Values are bounded