fix(providers): stop reporting an absent Ollama as an error

Ollama is optional and its URL falls back to a loopback default, so a deployment
that runs none refuses the probe on every poll — 10,068 of these in 14 days, the
single largest error stream in the app, all of them the same expected condition.

Report it the way the vLLM and LiteLLM routes already report an unconfigured
base URL, and skip the probe entirely on the hosted platform, which has no local
runtime to reach. An explicit OLLAMA_URL is still honoured everywhere, so a
self-hosted deployment behaves exactly as before — including the localhost
default that requires no configuration.

Author: waleedlatif1

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

@@ -0,0 +1,112 @@
+/**
+ * @vitest-environment node
+ */
+import { createMockRequest, resetEnvFlagsMock, setEnvFlags } from '@sim/testing'
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const {
+  mockFilterBlacklistedModels,
+  mockIsProviderBlacklisted,
+  mockFetch,
+  mockIsOllamaUrlConfigured,
+  ollamaLogger,
+} = vi.hoisted(() => ({
+  mockFilterBlacklistedModels: vi.fn(),
+  mockIsProviderBlacklisted: vi.fn(),
+  mockFetch: vi.fn(),
+  mockIsOllamaUrlConfigured: vi.fn(),
+  ollamaLogger: { info: vi.fn(), warn: vi.fn(), error: vi.fn(), debug: vi.fn() },
+}))
+
+vi.mock('@sim/logger', () => ({
+  createLogger: vi.fn(() => ollamaLogger),
+  logger: ollamaLogger,
+  runWithRequestContext: vi.fn(<T>(_ctx: unknown, fn: () => T): T => fn()),
+  getRequestContext: vi.fn(() => undefined),
+}))
+
+vi.mock('@/providers/utils', () => ({
+  filterBlacklistedModels: mockFilterBlacklistedModels,
+  isProviderBlacklisted: mockIsProviderBlacklisted,
+}))
+
+vi.mock('@/lib/core/utils/urls', () => ({
+  getOllamaUrl: () => 'http://localhost:11434',
+  isOllamaUrlConfigured: mockIsOllamaUrlConfigured,
+}))
+
+import { GET } from '@/app/api/providers/ollama/models/route'
+
+const request = () => createMockRequest('GET')
+
+describe('ollama models route', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    mockIsOllamaUrlConfigured.mockReturnValue(false)
+    mockIsProviderBlacklisted.mockReturnValue(false)
+    mockFilterBlacklistedModels.mockImplementation((models: string[]) => models)
+    vi.stubGlobal('fetch', mockFetch)
+    setEnvFlags({ isHosted: false })
+  })
+
+  afterAll(() => {
+    vi.unstubAllGlobals()
+    resetEnvFlagsMock()
+  })
+
+  it('does not probe a loopback Ollama on the hosted platform', async () => {
+    setEnvFlags({ isHosted: true })
+
+    const response = await GET(request())
+
+    await expect(response.json()).resolves.toEqual({ models: [] })
+    expect(mockFetch).not.toHaveBeenCalled()
+  })
+
+  it('still honours an explicit OLLAMA_URL on the hosted platform', async () => {
+    setEnvFlags({ isHosted: true })
+    mockIsOllamaUrlConfigured.mockReturnValue(true)
+    mockFetch.mockResolvedValue({ ok: true, json: async () => ({ models: [{ name: 'llama3' }] }) })
+
+    const response = await GET(request())
+
+    await expect(response.json()).resolves.toEqual({ models: ['llama3'] })
+    expect(mockFetch).toHaveBeenCalled()
+  })
+
+  it('probes the default host when self-hosted, so no configuration is required', async () => {
+    mockFetch.mockResolvedValue({ ok: true, json: async () => ({ models: [{ name: 'llama3' }] }) })
+
+    const response = await GET(request())
+
+    await expect(response.json()).resolves.toEqual({ models: ['llama3'] })
+    expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/api/tags'), expect.anything())
+  })
+
+  it('reports an unreachable Ollama as an empty list rather than a failure', async () => {
+    /**
+     * A deployment that runs no Ollama refuses this connection on every poll. The
+     * level is the point: an optional service being absent is not an error.
+     */
+    mockFetch.mockRejectedValue(new Error('Unable to connect. Is the computer able to access it?'))
+
+    const response = await GET(request())
+
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({ models: [] })
+    expect(ollamaLogger.error).not.toHaveBeenCalled()
+    expect(ollamaLogger.info).toHaveBeenCalledWith(
+      'Ollama service is not reachable, returning empty models',
+      expect.objectContaining({ host: expect.any(String) })
+    )
+  })
+
+  it('returns nothing when the provider is blacklisted', async () => {
+    mockIsProviderBlacklisted.mockReturnValue(true)
+
+    const response = await GET(request())
+
+    await expect(response.json()).resolves.toEqual({ models: [] })
+    expect(mockFetch).not.toHaveBeenCalled()
+  })
+})

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

@@ -5,7 +5,8 @@ import {
   ollamaUpstreamResponseSchema,
   providerModelsResponseSchema,
 } from '@/lib/api/contracts/providers'
-import { getOllamaUrl } from '@/lib/core/utils/urls'
+import { isHosted } from '@/lib/core/config/env-flags'
+import { getOllamaUrl, isOllamaUrlConfigured } from '@/lib/core/utils/urls'
 import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
 import { filterBlacklistedModels, isProviderBlacklisted } from '@/providers/utils'
 
@@ -21,6 +22,21 @@ export const GET = withRouteHandler(async (_request: NextRequest) => {
     return NextResponse.json({ models: [] })
   }
 
+  /**
+   * Ollama runs alongside the app it serves, so the hosted platform never has one
+   * and `OLLAMA_URL`'s loopback default cannot answer there. Skip the probe rather
+   * than dial an address known to refuse on every poll.
+   *
+   * Only the unconfigured default is skipped: an explicit `OLLAMA_URL` states an
+   * intent to reach a real server and is still honoured. Self-hosted deployments
+   * are untouched either way, including the localhost default that needs no
+   * configuration to work.
+   */
+  if (isHosted && !isOllamaUrlConfigured()) {
+    logger.info('Ollama is not available on the hosted platform, returning empty models')
+    return NextResponse.json({ models: [] })
+  }
+
   try {
     logger.info('Fetching Ollama models', {
       host: OLLAMA_HOST,
@@ -53,7 +69,14 @@ export const GET = withRouteHandler(async (_request: NextRequest) => {
 
     return NextResponse.json(providerModelsResponseSchema.parse({ models }))
   } catch (error) {
-    logger.error('Failed to fetch Ollama models', {
+    /**
+     * 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', {
       error: getErrorMessage(error, 'Unknown error'),
       host: OLLAMA_HOST,
     })

apps/sim/lib/core/utils/urls.ts

@@ -245,3 +245,12 @@ export function getSocketUrl(): string {
 export function getOllamaUrl(): string {
   return env.OLLAMA_URL || DEFAULT_OLLAMA_URL
 }
+
+/**
+ * Whether OLLAMA_URL names a server, as opposed to {@link getOllamaUrl} falling
+ * back to the loopback default. Callers use this to tell "someone pointed us at
+ * an Ollama" apart from "nobody configured one".
+ */
+export function isOllamaUrlConfigured(): boolean {
+  return Boolean(env.OLLAMA_URL)
+}