ODS V3 Pre-Release: Public testing and refinement ahead of the official V3 launch. Turn your PC, Mac, or Linux box into a private AI server.
Python ai-agentsamdcomfyuidockerllama-cppllmlocal-ain8nnvidiaopen-webuiragself-hostedspeech-to-textstrix-halotext-to-speechworkflow-automation
import { renderHook, waitFor, act } from '@testing-library/react'
import { getMockModels, MOCK_MODES, useModels } from '../useModels'
const UNMANAGED_HOST_RUNTIME = 'The model server on this computer is not managed by this ODS installation. Change the model in that server, or rerun the ODS installer to manage it here.'
// Shadow jsdom's Document.prototype.hidden getter on the instance; deleting
// the own property in afterEach restores the prototype behavior.
const setDocumentHidden = (hidden) => {
Object.defineProperty(document, 'hidden', { configurable: true, get: () => hidden })
}
const deferred = () => {
let resolve
let reject
const promise = new Promise((resolvePromise, rejectPromise) => {
resolve = resolvePromise
reject = rejectPromise
})
return { promise, resolve, reject }
}
const modelsResponse = (models, overrides = {}) => ({
ok: true,
json: () => Promise.resolve({
models,
gpu: null,
currentModel: null,
activationReadyModel: Object.prototype.hasOwnProperty.call(overrides, 'activationReadyModel')
? overrides.activationReadyModel
: (overrides.currentModel ?? null),
odsMode: 'local',
configuredMode: 'local',
llmBackend: 'llama-server',
...overrides,
})
})
describe('useModels', () => {
beforeEach(() => {
vi.stubGlobal('fetch', vi.fn())
})
afterEach(() => {
vi.restoreAllMocks()
delete document.hidden
})
test('development fixtures use unique model IDs and runnable local modes', () => {
const mockModels = getMockModels()
const modelIds = mockModels.map(model => model.id)
expect(new Set(modelIds).size).toBe(modelIds.length)
expect(modelIds).toContain('Qwen/Qwen2.5-32B-Instruct-AWQ')
expect(modelIds).toContain('Qwen/Qwen2.5-Coder-32B-Instruct-AWQ')
expect(MOCK_MODES).toEqual({ odsMode: 'local', configuredMode: 'local' })
})
test('fetches models on mount', async () => {
const mockData = {
models: [{ id: 'qwen-32b', name: 'Qwen2.5 32B' }],
gpu: { vramTotal: 16 },
currentModel: 'qwen-32b',
configuredModel: 'qwen-32b',
odsMode: 'cloud',
configuredMode: 'cloud',
recommendationAlternatives: [{ id: 'qwen-32b', name: 'Qwen2.5 32B' }]
}
fetch.mockResolvedValue({
ok: true,
json: () => Promise.resolve(mockData)
})
const { result } = renderHook(() => useModels())
await waitFor(() => {
expect(result.current.loading).toBe(false)
})
expect(result.current.models).toHaveLength(1)
expect(result.current.models[0].id).toBe('qwen-32b')
expect(result.current.gpu.vramTotal).toBe(16)
expect(result.current.currentModel).toBe('qwen-32b')
expect(result.current.configuredModel).toBe('qwen-32b')
expect(result.current.odsMode).toBe('cloud')
expect(result.current.configuredMode).toBe('cloud')
expect(result.current.canActivateModels).toBe(false)
expect(result.current.recommendationAlternatives[0].id).toBe('qwen-32b')
expect(result.current.error).toBeNull()
})
test('keeps observed runtime identity separate from catalog activation identity and clears it on unload', async () => {
fetch.mockResolvedValue(modelsResponse([], { loadedModel: 'owner-native-35b' }))
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
expect(result.current.loadedModel).toBe('owner-native-35b')
expect(result.current.currentModel).toBeNull()
expect(result.current.activationReadyModel).toBeNull()
fetch.mockResolvedValue(modelsResponse([]))
await act(async () => { await result.current.refresh() })
expect(result.current.loadedModel).toBeNull()
})
test('surfaces backend-owned activation as a pending model action', async () => {
const target = 'slow-model'
fetch.mockResolvedValue(modelsResponse(
[{
id: target,
status: 'downloaded',
modelOperation: {
active: true,
operation: 'model_activation',
modelId: target,
},
}],
{
modelLifecycle: {
active: true,
operation: 'model_activation',
target,
modelId: target,
},
}
))
const { result } = renderHook(() => useModels())
await waitFor(() => {
expect(result.current.loading).toBe(false)
})
expect(result.current.modelLifecycle).toEqual({
active: true,
operation: 'model_activation',
target,
modelId: target,
})
expect(result.current.activationLoading).toBe(target)
expect(result.current.actionLoadingModels).toEqual([target])
})
test('treats a missing runtime mode as unknown and blocks activation', async () => {
fetch.mockResolvedValue({
ok: true,
json: () => Promise.resolve({ models: [], gpu: null, currentModel: null }),
})
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
expect(result.current.odsMode).toBe('unknown')
expect(result.current.configuredMode).toBe('unknown')
expect(result.current.canActivateModels).toBe(false)
})
test('does not send a model activation POST in cloud mode', async () => {
const target = 'downloaded-model'
fetch.mockResolvedValue(modelsResponse(
[{ id: target, status: 'downloaded' }],
{ odsMode: 'cloud', configuredMode: 'cloud' }
))
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.odsMode).toBe('cloud'))
await act(async () => {
await result.current.loadModel(target)
})
const activationPosts = fetch.mock.calls.filter(([, options]) => options?.method === 'POST')
expect(activationPosts).toHaveLength(0)
expect(result.current.actionLoading).toBeNull()
expect(result.current.error).toBe('ODS is in cloud mode, so chat uses a model API. Downloaded models run only in local mode; if you connected that API in Settings > Remote model, switch back to the local model there.')
})
test('keeps browsing available but blocks local activation for an external backend', async () => {
const target = 'downloaded-model'
fetch.mockResolvedValue(modelsResponse(
[{ id: target, status: 'downloaded' }],
{ odsMode: 'local', configuredMode: 'local', llmBackend: 'external' }
))
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.llmBackend).toBe('external'))
expect(result.current.models).toHaveLength(1)
expect(result.current.canActivateModels).toBe(false)
await act(async () => {
await result.current.loadModel(target)
})
const activationPosts = fetch.mock.calls.filter(([, options]) => options?.method === 'POST')
expect(activationPosts).toHaveLength(0)
expect(result.current.error).toContain('ODS uses a model API')
expect(result.current.error).toContain('not used while API mode is on')
})
test.each([
[{ managed: false, canActivate: false, canUnload: false, running: false }, false],
[{ managed: true, canActivate: true, canUnload: true, running: true }, true],
])('a Windows-hosted server switches models only with its management proof (%j)', async (management, allowed) => {
const target = 'downloaded-model'
fetch.mockResolvedValue(modelsResponse(
[{ id: target, status: 'downloaded' }],
{ odsMode: 'local', configuredMode: 'local', llmBackend: 'llama-server', hostRuntime: true,
modelManagement: management }
))
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.hostRuntime).toBe(true))
expect(result.current.models).toHaveLength(1)
expect(result.current.canActivateModels).toBe(allowed)
if (allowed) return
expect(result.current.activationModeError).toBe(UNMANAGED_HOST_RUNTIME)
await act(async () => { await result.current.loadModel(target) })
expect(fetch.mock.calls.filter(([, options]) => options?.method === 'POST')).toHaveLength(0)
expect(result.current.error).toBe(UNMANAGED_HOST_RUNTIME)
})
test('the retired Lemonade mode is never read as a local mode', async () => {
fetch.mockResolvedValue(modelsResponse([], {
odsMode: 'lemonade', configuredMode: 'lemonade', llmBackend: 'llama-server',
}))
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
expect(result.current.odsMode).toBe('unknown')
expect(result.current.canActivateModels).toBe(false)
})
test('does not activate when effective and configured modes differ', async () => {
const target = 'downloaded-model'
fetch.mockResolvedValue(modelsResponse(
[{ id: target, status: 'downloaded' }],
{ odsMode: 'local', configuredMode: 'cloud' }
))
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.configuredMode).toBe('cloud'))
await act(async () => {
await result.current.loadModel(target)
})
const activationPosts = fetch.mock.calls.filter(([, options]) => options?.method === 'POST')
expect(activationPosts).toHaveLength(0)
expect(result.current.canActivateModels).toBe(false)
expect(result.current.error).toContain('running in local mode but configured for cloud mode')
})
test('sets error on fetch failure', async () => {
fetch.mockResolvedValue({ ok: false })
const { result } = renderHook(() => useModels())
await waitFor(() => {
expect(result.current.error).toBeTruthy()
})
expect(result.current.loading).toBe(false)
})
test('downloadModel calls POST and refreshes', async () => {
fetch.mockImplementation((url, opts) => {
if (opts?.method === 'POST') {
return Promise.resolve({ ok: true, json: () => Promise.resolve({}) })
}
return Promise.resolve({
ok: true,
json: () => Promise.resolve({ models: [{ id: 'new-model' }], gpu: null, currentModel: null })
})
})
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
await act(async () => {
await result.current.downloadModel('new-model')
})
const postCall = fetch.mock.calls.find(c => c[1]?.method === 'POST')
expect(postCall[0]).toBe('/api/models/new-model/download')
expect(Object.keys(postCall[1]).sort()).toEqual(['method', 'signal'])
expect(postCall[1]).toMatchObject({ method: 'POST' })
expect(postCall[1].signal).toBeInstanceOf(globalThis.AbortSignal)
})
test('loadModel sends the exact encoded activation request', async () => {
vi.useFakeTimers()
const target = 'org/model q4'
let currentModel = null
fetch.mockImplementation((_url, options) => {
if (options?.method === 'POST') {
currentModel = target
return Promise.resolve({ ok: true })
}
return Promise.resolve(modelsResponse(
[{ id: target, status: currentModel ? 'loaded' : 'downloaded' }],
{ currentModel }
))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target)
})
const postCall = fetch.mock.calls.find(c => c[1]?.method === 'POST')
expect(postCall[0]).toBe('/api/models/org%2Fmodel%20q4/load')
expect(Object.keys(postCall[1]).sort()).toEqual(['method', 'signal'])
expect(postCall[1]).toMatchObject({ method: 'POST' })
expect(postCall[1].signal).toBeInstanceOf(globalThis.AbortSignal)
await act(async () => {
await vi.advanceTimersByTimeAsync(5000)
await loadPromise
})
} finally {
vi.useRealTimers()
}
})
test('loadModel reports an active Pixel turn without inventing a model conflict', async () => {
vi.useFakeTimers()
const target = 'next-model'
fetch.mockImplementation((_url, options) => {
if (options?.method === 'POST') {
return Promise.resolve({
ok: false,
status: 409,
json: () => Promise.resolve({
detail: {
code: 'pixel_chat_active',
message: 'Portal is working. Stop the active response before changing models.',
requestedModelId: target,
},
}),
})
}
return Promise.resolve(modelsResponse([{ id: target, status: 'downloaded' }]))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target)
})
await act(async () => {
await vi.advanceTimersByTimeAsync(5000)
await loadPromise
})
expect(result.current.error).toBe(
'Portal is working. Stop the active response before changing models.'
)
expect(result.current.error).not.toMatch(/active target|server did not identify/i)
} finally {
vi.useRealTimers()
}
})
test('loadModel sends context and waits for the requested runtime context', async () => {
vi.useFakeTimers()
const target = 'qwen-long-context'
let contextLength = 65536
fetch.mockImplementation((_url, options) => {
if (options?.method === 'POST') {
const body = JSON.parse(options.body)
contextLength = body.context_length
return Promise.resolve({ ok: true })
}
return Promise.resolve(modelsResponse(
[{ id: target, status: 'loaded', contextLength }],
{ currentModel: target }
))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target, { contextLength: 262144 })
})
const postCall = fetch.mock.calls.find(c => c[1]?.method === 'POST')
expect(postCall[0]).toBe('/api/models/qwen-long-context/load')
expect(postCall[1]).toMatchObject({
method: 'POST',
headers: { 'Content-Type': 'application/json' },
body: JSON.stringify({ context_length: 262144 }),
})
await act(async () => {
await vi.advanceTimersByTimeAsync(5000)
await loadPromise
})
expect(result.current.models[0].contextLength).toBe(262144)
expect(result.current.error).toBeNull()
} finally {
vi.useRealTimers()
}
})
test('keeps activation pending until downstream synchronization is receipted', async () => {
vi.useFakeTimers()
const target = 'qwen-model'
let currentModel = null
let activationReadyModel = null
fetch.mockImplementation((_url, options) => {
if (options?.method === 'POST') {
currentModel = target
return Promise.resolve({ ok: true })
}
return Promise.resolve(modelsResponse(
[{ id: target, status: currentModel ? 'loaded' : 'downloaded' }],
{ currentModel, activationReadyModel }
))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target)
})
await act(async () => { await vi.advanceTimersByTimeAsync(5000) })
expect(result.current.currentModel).toBe(target)
expect(result.current.activationReadyModel).toBeNull()
expect(result.current.actionLoading).toBe(target)
activationReadyModel = target
await act(async () => {
await vi.advanceTimersByTimeAsync(5000)
await loadPromise
})
expect(result.current.activationReadyModel).toBe(target)
expect(result.current.actionLoading).toBeNull()
expect(result.current.error).toBeNull()
} finally {
vi.useRealTimers()
}
})
test('confirms a committed activation as soon as the server answers', async () => {
vi.useFakeTimers()
const target = 'fast-model'
let currentModel = null
const activation = deferred()
fetch.mockImplementation((_url, options) => {
if (options?.method === 'POST') return activation.promise
return Promise.resolve(modelsResponse(
[{ id: target, status: currentModel ? 'loaded' : 'downloaded' }],
{ currentModel }
))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let settled = false
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target).then(() => { settled = true })
})
await act(async () => { await vi.advanceTimersByTimeAsync(1000) })
expect(settled).toBe(false)
expect(result.current.actionLoading).toBe(target)
currentModel = target
activation.resolve({ ok: true })
// Far inside the 5-second activation poll interval.
await act(async () => { await vi.advanceTimersByTimeAsync(10) })
expect(settled).toBe(true)
expect(result.current.actionLoading).toBeNull()
expect(result.current.error).toBeNull()
await loadPromise
} finally {
vi.useRealTimers()
}
})
test('cuts only one activation poll short when status lags the answer', async () => {
vi.useFakeTimers()
const target = 'lagging-model'
let currentModel = null
fetch.mockImplementation((_url, options) => {
if (options?.method === 'POST') return Promise.resolve({ ok: true })
return Promise.resolve(modelsResponse(
[{ id: target, status: currentModel ? 'loaded' : 'downloaded' }],
{ currentModel }
))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target)
})
const callsBefore = fetch.mock.calls.length
await act(async () => { await vi.advanceTimersByTimeAsync(4000) })
const statusReads = fetch.mock.calls
.slice(callsBefore)
.filter(call => call[1]?.method !== 'POST').length
// One immediate confirmation plus the regular background polls: the
// answered request must never turn the wait into a request loop.
expect(statusReads).toBeLessThanOrEqual(5)
expect(result.current.actionLoading).toBe(target)
currentModel = target
await act(async () => {
await vi.advanceTimersByTimeAsync(5000)
await loadPromise
})
expect(result.current.actionLoading).toBeNull()
expect(result.current.error).toBeNull()
} finally {
vi.useRealTimers()
}
})
test('aborts a hung download start and releases its pending action for retry', async () => {
vi.useFakeTimers()
let postCount = 0
fetch.mockImplementation((_url, options) => {
if (options?.method === 'POST') {
postCount += 1
return new Promise((_resolve, reject) => {
options.signal.addEventListener('abort', () => {
const error = new Error('The operation was aborted.')
error.name = 'AbortError'
reject(error)
}, { once: true })
})
}
return Promise.resolve(modelsResponse([{ id: 'new-model', status: 'available' }]))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let firstError
let firstDownload
act(() => {
firstDownload = result.current.downloadModel('new-model').catch((error) => {
firstError = error
})
})
expect(result.current.actionLoading).toBe('new-model')
expect(postCount).toBe(1)
await act(async () => {
await vi.advanceTimersByTimeAsync(15000)
await firstDownload
})
expect(firstError?.message).toMatch(/did not start within 15 seconds/i)
expect(result.current.actionLoading).toBeNull()
expect(result.current.error).toBeNull()
let retryDownload
act(() => {
retryDownload = result.current.downloadModel('new-model').catch(() => {})
})
expect(postCount).toBe(2)
expect(result.current.actionLoading).toBe('new-model')
await act(async () => {
await vi.advanceTimersByTimeAsync(15000)
await retryDownload
})
expect(result.current.actionLoading).toBeNull()
} finally {
vi.useRealTimers()
}
})
test('keeps unrelated mutation errors separate from download start failures', async () => {
fetch.mockImplementation((_url, options) => {
if (options?.method === 'DELETE') {
return Promise.resolve({
ok: false,
json: () => Promise.resolve({ detail: 'Delete is blocked by the active runtime.' }),
})
}
if (options?.method === 'POST') {
return Promise.resolve({
ok: false,
json: () => Promise.resolve({ detail: 'Download service is unavailable.' }),
})
}
return Promise.resolve(modelsResponse([{ id: 'new-model', status: 'available' }]))
})
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
await act(async () => {
await result.current.deleteModel('old-model')
})
expect(result.current.error).toBe('Delete is blocked by the active runtime.')
let downloadError
await act(async () => {
try {
await result.current.downloadModel('new-model')
} catch (error) {
downloadError = error
}
})
expect(downloadError?.message).toBe('Download service is unavailable.')
expect(result.current.error).toBe('Delete is blocked by the active runtime.')
})
test('clears a pending download when an independent refresh confirms completion', async () => {
const downloadRequest = deferred()
let snapshot = [{ id: 'new-model', status: 'available' }]
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'POST') return downloadRequest.promise
return Promise.resolve(modelsResponse(snapshot))
})
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
let downloadPromise
act(() => {
downloadPromise = result.current.downloadModel('new-model')
})
await waitFor(() => expect(result.current.actionLoading).toBe('new-model'))
snapshot = [{ id: 'new-model', status: 'downloaded' }]
await act(async () => {
await result.current.refresh()
})
expect(result.current.actionLoading).toBeNull()
await act(async () => {
downloadRequest.resolve({ ok: true })
await downloadPromise
})
})
test('deleteModel calls DELETE and refreshes', async () => {
vi.stubGlobal('confirm', vi.fn(() => { throw new Error('Native delete confirmation should stay in the page UI.') }))
const target = 'org/model q4'
fetch.mockImplementation((url, opts) => {
if (opts?.method === 'DELETE') {
return Promise.resolve({ ok: true, json: () => Promise.resolve({}) })
}
return Promise.resolve({
ok: true,
json: () => Promise.resolve({ models: [], gpu: null, currentModel: null })
})
})
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
await act(async () => {
await result.current.deleteModel(target)
})
expect(confirm).not.toHaveBeenCalled()
const deleteCall = fetch.mock.calls.find(c => c[1]?.method === 'DELETE')
expect(deleteCall).toEqual(['/api/models/org%2Fmodel%20q4', { method: 'DELETE', signal: expect.any(AbortSignal) }])
})
test('clears a pending delete when an independent refresh confirms removal', async () => {
const deleteRequest = deferred()
let snapshot = [{ id: 'to-delete', status: 'downloaded' }]
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'DELETE') return deleteRequest.promise
return Promise.resolve(modelsResponse(snapshot))
})
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
let deletePromise
act(() => {
deletePromise = result.current.deleteModel('to-delete')
})
await waitFor(() => expect(result.current.actionLoading).toBe('to-delete'))
snapshot = []
await act(async () => {
await result.current.refresh()
})
expect(result.current.actionLoading).toBeNull()
await act(async () => {
deleteRequest.resolve({ ok: true })
await deletePromise
})
})
test('shows the backend delete explanation instead of a generic failure', async () => {
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'DELETE') {
return Promise.resolve({
ok: false,
status: 409,
json: () => Promise.resolve({ detail: 'The active model must be stopped before deleting its file.' })
})
}
return Promise.resolve(modelsResponse([{ id: 'to-delete', status: 'downloaded' }]))
})
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
await act(async () => {
await result.current.deleteModel('to-delete')
})
expect(result.current.error).toBe('The active model must be stopped before deleting its file.')
expect(result.current.actionLoading).toBeNull()
})
test('does not erase a mutation error when background list polling succeeds', async () => {
vi.useFakeTimers()
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'DELETE') {
return Promise.resolve({
ok: false,
status: 409,
json: () => Promise.resolve({ detail: 'Delete blocked by the active runtime.' })
})
}
return Promise.resolve(modelsResponse([{ id: 'to-delete', status: 'downloaded' }]))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
await act(async () => {
await result.current.deleteModel('to-delete')
})
expect(result.current.error).toBe('Delete blocked by the active runtime.')
await act(async () => { await vi.advanceTimersByTimeAsync(30000) })
expect(result.current.error).toBe('Delete blocked by the active runtime.')
} finally {
vi.useRealTimers()
}
})
test('keeps activation working while an overlapping model mutation settles', async () => {
vi.useFakeTimers()
const target = 'slow-model'
const otherModel = 'other-model'
const deleteRequest = deferred()
let currentModel = null
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'POST') return Promise.resolve({ ok: true })
if (opts?.method === 'DELETE') return deleteRequest.promise
return Promise.resolve(modelsResponse(
[
{ id: target, status: currentModel ? 'loaded' : 'downloaded' },
{ id: otherModel, status: 'downloaded' },
],
{ currentModel }
))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target)
})
expect(result.current.actionLoading).toBe(target)
expect(result.current.actionLoadingModels).toEqual([target])
let deletePromise
act(() => {
deletePromise = result.current.deleteModel(otherModel)
})
expect(result.current.actionLoading).toBe(target)
expect(result.current.actionLoadingModels).toEqual([target, otherModel])
await act(async () => {
deleteRequest.resolve({ ok: true })
await deletePromise
})
expect(result.current.actionLoading).toBe(target)
expect(result.current.actionLoadingModels).toEqual([target])
currentModel = target
await act(async () => {
await vi.advanceTimersByTimeAsync(5000)
await loadPromise
})
expect(result.current.actionLoading).toBeNull()
expect(result.current.actionLoadingModels).toEqual([])
} finally {
vi.useRealTimers()
}
})
test('keeps activation pending beyond 150 seconds until the requested model is loaded', async () => {
vi.useFakeTimers()
const target = 'slow-model'
let currentModel = null
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'POST') return Promise.resolve({ ok: true })
return Promise.resolve(modelsResponse(
[{ id: target, status: currentModel ? 'loaded' : 'downloaded' }],
{ currentModel }
))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target)
})
await act(async () => { await vi.advanceTimersByTimeAsync(155000) })
expect(result.current.actionLoading).toBe(target)
expect(result.current.error).toBeNull()
currentModel = target
await act(async () => {
await vi.advanceTimersByTimeAsync(5000)
await loadPromise
})
expect(result.current.currentModel).toBe(target)
expect(result.current.actionLoading).toBeNull()
expect(result.current.error).toBeNull()
} finally {
vi.useRealTimers()
}
})
test('keeps activation pending while backend activation lifecycle is still active', async () => {
vi.useFakeTimers()
const target = 'warmup-model'
let currentModel = null
let activationActive = false
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'POST') return Promise.resolve({ ok: true })
return Promise.resolve(modelsResponse(
[{ id: target, status: currentModel ? 'loaded' : 'downloaded' }],
{
currentModel,
modelLifecycle: activationActive
? {
active: true,
operation: 'model_activation',
target,
modelId: target,
}
: null,
}
))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target)
})
currentModel = target
activationActive = true
await act(async () => { await vi.advanceTimersByTimeAsync(5000) })
expect(result.current.currentModel).toBe(target)
expect(result.current.actionLoading).toBe(target)
expect(result.current.error).toBeNull()
activationActive = false
await act(async () => {
await vi.advanceTimersByTimeAsync(5000)
await loadPromise
})
expect(result.current.actionLoading).toBeNull()
expect(result.current.error).toBeNull()
} finally {
vi.useRealTimers()
}
})
test('holds the activation lock through the host budget and retry grace', async () => {
vi.useFakeTimers()
const target = 'never-loads'
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'POST') return Promise.resolve({ ok: true })
return Promise.resolve(modelsResponse([{ id: target, status: 'downloaded' }]))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target)
})
await act(async () => { await vi.advanceTimersByTimeAsync(2820000) })
expect(result.current.actionLoading).toBe(target)
expect(result.current.error).toBeNull()
await act(async () => {
await vi.advanceTimersByTimeAsync(5000)
await loadPromise
})
expect(result.current.actionLoading).toBeNull()
expect(result.current.error).toMatch(/timed out after 47 minutes/i)
expect(result.current.error).toContain(target)
} finally {
vi.useRealTimers()
}
})
test.each([
['root payload', { detail: 'Activation already in progress', activeModelId: 'same-target' }],
['nested detail payload', { detail: { message: 'Activation already in progress', activeModelId: 'same-target' } }],
])('continues waiting for a same-target 409 from a %s', async (_label, conflictBody) => {
vi.useFakeTimers()
const target = 'same-target'
let currentModel = null
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'POST') {
return Promise.resolve({
ok: false,
status: 409,
json: () => Promise.resolve(conflictBody),
})
}
return Promise.resolve(modelsResponse(
[{ id: target, status: currentModel ? 'loaded' : 'downloaded' }],
{ currentModel }
))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target)
})
await act(async () => { await vi.advanceTimersByTimeAsync(5000) })
expect(result.current.actionLoading).toBe(target)
expect(result.current.error).toBeNull()
currentModel = target
await act(async () => {
await vi.advanceTimersByTimeAsync(5000)
await loadPromise
})
expect(result.current.actionLoading).toBeNull()
expect(result.current.error).toBeNull()
} finally {
vi.useRealTimers()
}
})
test.each([
[
'different target',
{ detail: { error: 'Activation already in progress', activeModelId: 'other-model' } },
/active target: other-model; requested target: requested-model/i,
],
[
'unknown target',
{ detail: 'Activation already in progress' },
/did not identify the active target/i,
],
])('rejects a 409 with a %s instead of joining it', async (_label, conflictBody, expectedError) => {
vi.useFakeTimers()
const baseline = 'baseline-model'
const target = 'requested-model'
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'POST') {
return Promise.resolve({
ok: false,
status: 409,
json: () => Promise.resolve(conflictBody),
})
}
return Promise.resolve(modelsResponse(
[
{ id: baseline, status: 'loaded' },
{ id: target, status: 'downloaded' },
],
{ currentModel: baseline }
))
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
let loadPromise
act(() => {
loadPromise = result.current.loadModel(target)
})
await act(async () => {
await vi.advanceTimersByTimeAsync(5000)
await loadPromise
})
expect(result.current.currentModel).toBe(baseline)
expect(result.current.actionLoading).toBeNull()
expect(result.current.error).toMatch(expectedError)
} finally {
vi.useRealTimers()
}
})
test('late mutation settlement does not clear a newer action', async () => {
const oldDownload = deferred()
const newDownload = deferred()
fetch.mockImplementation((url, opts) => {
if (opts?.method === 'POST') {
return String(url).includes('old-model') ? oldDownload.promise : newDownload.promise
}
return Promise.resolve(modelsResponse([
{ id: 'old-model', status: 'available' },
{ id: 'new-model', status: 'available' }
]))
})
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
let oldPromise
act(() => {
oldPromise = result.current.downloadModel('old-model')
})
await waitFor(() => expect(result.current.actionLoading).toBe('old-model'))
let newPromise
act(() => {
newPromise = result.current.downloadModel('new-model')
})
await waitFor(() => expect(result.current.actionLoading).toBe('new-model'))
await act(async () => {
oldDownload.resolve({ ok: true })
await oldPromise
})
expect(result.current.actionLoading).toBe('new-model')
await act(async () => {
newDownload.resolve({ ok: true })
await newPromise
})
expect(result.current.actionLoading).toBeNull()
})
test('keeps only one prompt poll in flight while a model action is pending', async () => {
vi.useFakeTimers()
const downloadRequest = deferred()
const pendingPoll = deferred()
let getCount = 0
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'POST') return downloadRequest.promise
getCount += 1
if (getCount === 1) return Promise.resolve(modelsResponse([{ id: 'new-model', status: 'available' }]))
return pendingPoll.promise
})
try {
const { result } = renderHook(() => useModels())
await act(async () => {})
expect(getCount).toBe(1)
let downloadPromise
act(() => {
downloadPromise = result.current.downloadModel('new-model')
})
expect(result.current.actionLoading).toBe('new-model')
await act(async () => { await vi.advanceTimersByTimeAsync(2000) })
expect(getCount).toBe(2)
await act(async () => { await vi.advanceTimersByTimeAsync(10000) })
expect(getCount).toBe(2)
await act(async () => {
pendingPoll.resolve(modelsResponse([{ id: 'new-model', status: 'downloaded' }]))
await pendingPoll.promise
})
expect(result.current.actionLoading).toBeNull()
await act(async () => { await vi.advanceTimersByTimeAsync(2000) })
expect(getCount).toBe(2)
downloadRequest.resolve({ ok: true })
await act(async () => { await downloadPromise })
} finally {
vi.useRealTimers()
}
})
test('recovers polling after a models request exceeds its deadline', async () => {
vi.useFakeTimers()
let getCount = 0
fetch.mockImplementation((_url, options) => {
getCount += 1
if (getCount > 1) {
return Promise.resolve(modelsResponse([{ id: 'recovered', status: 'loaded' }]))
}
return new Promise((_resolve, reject) => {
options.signal.addEventListener('abort', () => {
const error = new Error('The operation was aborted.')
error.name = 'AbortError'
reject(error)
}, { once: true })
})
})
try {
const { result } = renderHook(() => useModels())
expect(getCount).toBe(1)
await act(async () => { await vi.advanceTimersByTimeAsync(30000) })
expect(result.current.loading).toBe(false)
expect(getCount).toBe(2)
expect(result.current.models[0].id).toBe('recovered')
expect(result.current.error).toBeNull()
} finally {
vi.useRealTimers()
}
})
test('does not let an older models response overwrite a newer snapshot', async () => {
const firstRequest = deferred()
const secondRequest = deferred()
let getCount = 0
fetch.mockImplementation(() => {
getCount += 1
return getCount === 1 ? firstRequest.promise : secondRequest.promise
})
const { result } = renderHook(() => useModels())
expect(getCount).toBe(1)
let refreshPromise
act(() => {
refreshPromise = result.current.refresh()
})
expect(getCount).toBe(2)
await act(async () => {
secondRequest.resolve(modelsResponse([{ id: 'new-snapshot', status: 'loaded' }]))
await refreshPromise
})
expect(result.current.models[0].id).toBe('new-snapshot')
await act(async () => {
firstRequest.resolve(modelsResponse([{ id: 'stale-snapshot', status: 'available' }]))
await firstRequest.promise
await Promise.resolve()
})
expect(result.current.models[0].id).toBe('new-snapshot')
})
test('benchmarkModel calls POST and refreshes', async () => {
fetch.mockImplementation((url, opts) => {
if (opts?.method === 'POST' && String(url).includes('/benchmark')) {
return Promise.resolve({ ok: true, json: () => Promise.resolve({ tokensPerSecond: 42 }) })
}
return Promise.resolve({
ok: true,
json: () => Promise.resolve({ models: [{ id: 'qwen3.5-9b-q4' }], gpu: null, currentModel: 'qwen3.5-9b-q4' })
})
})
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
await act(async () => {
await result.current.benchmarkModel('qwen3.5-9b-q4')
})
const benchmarkCall = fetch.mock.calls.find(c => c[1]?.method === 'POST' && String(c[0]).includes('/benchmark'))
expect(benchmarkCall).toBeTruthy()
expect(benchmarkCall[0]).toContain('qwen3.5-9b-q4')
expect(benchmarkCall[1].body).toContain('max_tokens')
})
test('pauses 30s polling while the tab is hidden and refreshes on visibilitychange', async () => {
fetch.mockResolvedValue({
ok: true,
json: () => Promise.resolve({ models: [], gpu: null, currentModel: null })
})
vi.useFakeTimers()
try {
renderHook(() => useModels())
await act(async () => {})
expect(fetch).toHaveBeenCalledTimes(1)
setDocumentHidden(true)
await act(async () => { await vi.advanceTimersByTimeAsync(90000) })
expect(fetch).toHaveBeenCalledTimes(1)
setDocumentHidden(false)
await act(async () => {
document.dispatchEvent(new Event('visibilitychange'))
})
expect(fetch).toHaveBeenCalledTimes(2)
await act(async () => { await vi.advanceTimersByTimeAsync(30000) })
expect(fetch).toHaveBeenCalledTimes(3)
} finally {
vi.useRealTimers()
}
})
test('deleteModel does not depend on native confirm cancellation', async () => {
vi.stubGlobal('confirm', vi.fn(() => false))
fetch.mockImplementation((_url, opts) => {
if (opts?.method === 'DELETE') {
return Promise.resolve({ ok: true, json: () => Promise.resolve({}) })
}
return Promise.resolve(modelsResponse([{ id: 'keep-me', status: 'downloaded' }]))
})
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
await act(async () => {
await result.current.deleteModel('keep-me')
})
expect(confirm).not.toHaveBeenCalled()
expect(fetch.mock.calls.some(call => call[1]?.method === 'DELETE')).toBe(true)
})
test.each([
['model_delete_cleanup_pending', true, true],
['model_delete_status_update_failed', true, true],
['model_delete_status_update_failed', false, false],
['model_delete_status_update_failed', 'true', false],
['model_delete_recovery_required', false, false],
['model_delete_recovery_required', true, false],
['model_delete_cleanup_pending', false, false],
['model_delete_cleanup_pending', 'true', false],
['unrelated_failure', true, false],
])('deletion %s with committed=%s refreshes only proven retirement', async (code, committed, refresh) => {
let retired = false
const message = 'Cleanup is incomplete in model store directory .ods-model-delete-receipt'
fetch.mockImplementation(async (_url, options = {}) => {
if (options.method === 'DELETE') {
retired = true
return { ok: false, status: 502, json: async () => ({ detail: {
error: message, code, deletionCommitted: committed,
recoveryDirectory: '.ods-model-delete-receipt',
} }) }
}
return modelsResponse([{ id: 'inactive', status: retired ? 'available' : 'downloaded' }])
})
const view = renderHook(() => useModels())
await waitFor(() => expect(view.result.current.loading).toBe(false))
setDocumentHidden(true) // Isolate immediate reconciliation from background polling.
expect(view.result.current.models[0].status).toBe('downloaded')
await act(async () => { await view.result.current.deleteModel('inactive') })
expect(view.result.current.error).toBe(message)
expect(view.result.current.models[0].status).toBe(refresh ? 'available' : 'downloaded')
expect(fetch.mock.calls.filter(([, options]) => options?.method !== 'DELETE')).toHaveLength(refresh ? 2 : 1)
expect(view.result.current.actionLoadingModels).toEqual([])
view.unmount()
})
test('successful deletion reconciles exactly once', async () => {
let retired = false
fetch.mockImplementation(async (_url, options = {}) => {
if (options.method === 'DELETE') {
retired = true
return { ok: true, json: async () => ({ status: 'deleted' }) }
}
return modelsResponse([{ id: 'inactive', status: retired ? 'available' : 'downloaded' }])
})
const view = renderHook(() => useModels())
await waitFor(() => expect(view.result.current.loading).toBe(false))
setDocumentHidden(true)
await act(async () => { await view.result.current.deleteModel('inactive') })
expect(view.result.current.models[0].status).toBe('available')
expect(view.result.current.error).toBeNull()
expect(fetch.mock.calls.filter(([, options]) => options?.method !== 'DELETE')).toHaveLength(2)
view.unmount()
})
test('propagates a validated remote-provider activeRuntime', async () => {
fetch.mockResolvedValue(modelsResponse([], {
llmBackend: 'llama-server',
loadedModel: 'Qwen3.5-9B-Q4_K_M.gguf',
activeRuntime: {
source: 'remote-provider',
model: 'deepseek-v4.1-flash',
contextLength: 131072,
maxTokens: 8192,
reasoning: true,
routeFingerprint: 'a'.repeat(64),
},
}))
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
expect(result.current.activeRuntime).toEqual({
source: 'remote-provider',
model: 'deepseek-v4.1-flash',
contextLength: 131072,
})
// Local engine identity is preserved separately.
expect(result.current.loadedModel).toBe('Qwen3.5-9B-Q4_K_M.gguf')
expect(result.current.llmBackend).toBe('llama-server')
expect(result.current.canActivateModels).toBe(false)
await act(async () => { await result.current.loadModel('qwen3.5-9b-q4') })
expect(fetch.mock.calls.some(([, options]) => options?.method === 'POST')).toBe(false)
})
test('clears activeRuntime on fetch failure so a stale route is not claimed active', async () => {
fetch.mockResolvedValueOnce(modelsResponse([], {
activeRuntime: {
source: 'remote-provider',
model: 'deepseek-v4.1-flash',
contextLength: 131072,
maxTokens: 8192,
reasoning: true,
},
}))
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.activeRuntime?.model).toBe('deepseek-v4.1-flash'))
fetch.mockResolvedValueOnce({ ok: false })
await act(async () => {
await result.current.refresh()
})
expect(result.current.activeRuntime).toBeNull()
expect(result.current.error).toBeTruthy()
})
test('ignores malformed activeRuntime projections', async () => {
fetch.mockResolvedValue(modelsResponse([], {
activeRuntime: { source: 'remote-provider', model: '', contextLength: 0 },
}))
const { result } = renderHook(() => useModels())
await waitFor(() => expect(result.current.loading).toBe(false))
expect(result.current.activeRuntime).toBeNull()
})
})