fix(providers): keep an unreadable Ollama response out of the not-reachable path

The single catch covered the connection, the JSON read, and the schema parse, so a
server that answered but answered wrongly was filed as 'no Ollama here'. Scope the
quiet path to the connection itself and report an unusable response as the fault
it is.

Author: waleedlatif1

apps/sim/app/api/providers/ollama/models/route.test.ts

@@ -109,4 +109,56 @@ describe('ollama models route', () => {
     await expect(response.json()).resolves.toEqual({ models: [] })
     expect(mockFetch).not.toHaveBeenCalled()
   })
+
+  it('reports an unreadable response as an error, not as absence', async () => {
+    /**
+     * Something answered 2xx but did not return a tag listing. Unlike a refused
+     * connection that is a real fault, and must not be filed under "no Ollama here".
+     */
+    mockFetch.mockResolvedValue({
+      ok: true,
+      json: async () => {
+        throw new SyntaxError('Unexpected token < in JSON at position 0')
+      },
+    })
+
+    const response = await GET(request())
+
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({ models: [] })
+    expect(ollamaLogger.error).toHaveBeenCalledWith(
+      'Ollama returned a response this route cannot read',
+      expect.objectContaining({ host: expect.any(String) })
+    )
+  })
+
+  it('reports a non-2xx response as unavailable', async () => {
+    mockFetch.mockResolvedValue({ ok: false, status: 503, statusText: 'Service Unavailable' })
+
+    const response = await GET(request())
+
+    await expect(response.json()).resolves.toEqual({ models: [] })
+    expect(ollamaLogger.warn).toHaveBeenCalled()
+    expect(ollamaLogger.error).not.toHaveBeenCalled()
+  })
+
+  it('reports a wrongly-shaped tag listing as an error', async () => {
+    /** Reachable and 2xx, but the entries are not Ollama models. */
+    mockFetch.mockResolvedValue({ ok: true, json: async () => ({ models: [{ noName: true }] }) })
+
+    const response = await GET(request())
+
+    await expect(response.json()).resolves.toEqual({ models: [] })
+    expect(ollamaLogger.error).toHaveBeenCalled()
+  })
+
+  it('accepts a listing with no models as simply empty', async () => {
+    /** The schema defaults `models` to [], so an empty answer is not a fault. */
+    mockFetch.mockResolvedValue({ ok: true, json: async () => ({}) })
+
+    const response = await GET(request())
+
+    await expect(response.json()).resolves.toEqual({ models: [] })
+    expect(ollamaLogger.error).not.toHaveBeenCalled()
+  })
 })

apps/sim/app/api/providers/ollama/models/route.ts

@@ -37,26 +37,46 @@ export const GET = withRouteHandler(async (_request: NextRequest) => {
     return NextResponse.json({ models: [] })
   }
 
-  try {
-    logger.info('Fetching Ollama models', {
-      host: OLLAMA_HOST,
-    })
+  logger.info('Fetching Ollama models', {
+    host: OLLAMA_HOST,
+  })
 
-    const response = await fetch(`${OLLAMA_HOST}/api/tags`, {
+  let response: Response
+  try {
+    response = await fetch(`${OLLAMA_HOST}/api/tags`, {
       headers: {
         'Content-Type': 'application/json',
       },
       next: { revalidate: 60 },
     })
+  } catch (error) {
+    /**
+     * Ollama is optional, so a deployment that does not run one refuses the
+     * connection on every poll. That is an expected state rather than a failure of
+     * this route — the same condition its siblings report when `VLLM_BASE_URL` or
+     * `LITELLM_BASE_URL` is absent — and the response is the same empty list a
+     * blacklisted provider returns.
+     *
+     * Scoped to the connection itself: a server that answers but answers wrongly is
+     * a real fault and is reported as one below.
+     */
+    logger.info('Ollama service is not reachable, returning empty models', {
+      error: getErrorMessage(error, 'Unknown error'),
+      host: OLLAMA_HOST,
+    })
 
-    if (!response.ok) {
-      logger.warn('Ollama service is not available', {
-        status: response.status,
-        statusText: response.statusText,
-      })
-      return NextResponse.json({ models: [] })
-    }
+    return NextResponse.json({ models: [] })
+  }
+
+  if (!response.ok) {
+    logger.warn('Ollama service is not available', {
+      status: response.status,
+      statusText: response.statusText,
+    })
+    return NextResponse.json({ models: [] })
+  }
 
+  try {
     const data = ollamaUpstreamResponseSchema.parse(await response.json())
     const allModels = data.models.map((model) => model.name)
     const models = filterBlacklistedModels(allModels)
@@ -69,14 +89,8 @@ export const GET = withRouteHandler(async (_request: NextRequest) => {
 
     return NextResponse.json(providerModelsResponseSchema.parse({ models }))
   } catch (error) {
-    /**
-     * Ollama is optional, so a deployment that does not run one refuses the
-     * connection on every poll. That is an expected state rather than a failure of
-     * this route — the same condition its siblings report when `VLLM_BASE_URL` or
-     * `LITELLM_BASE_URL` is absent — and the response is the same empty list a
-     * blacklisted provider returns.
-     */
-    logger.info('Ollama service is not reachable, returning empty models', {
+    /** Something is listening and returned 2xx, but not an Ollama tag listing. */
+    logger.error('Ollama returned a response this route cannot read', {
       error: getErrorMessage(error, 'Unknown error'),
       host: OLLAMA_HOST,
     })