feat(embeddings): load OpenRouter model catalog

Author: TheodoreSpeaks

apps/docs/content/docs/en/integrations/embeddings.mdx

@@ -57,7 +57,7 @@ Generate embeddings from text using OpenAI's embedding models
 
 ### OpenRouter Embeddings
 
-Generate embeddings from OpenAI embedding models through OpenRouter
+Generate embeddings through OpenRouter
 
 #### Input
 
@@ -67,7 +67,7 @@ Generate embeddings from OpenAI embedding models through OpenRouter
 | `model` | string | No | Embedding model to use |
 | `taskType` | string | No | What the embedding is for, when the model supports task conditioning: document, query, similarity, classification, or clustering |
 | `dimensions` | number | No | Output dimensions, when the model supports truncation. Defaults to native. |
-| `apiKey` | string | No | OpenRouter API key; optional on self-hosted deployments with OPENROUTER_API_KEY configured |
+| `apiKey` | string | Yes | API key for the selected embedding provider |
 
 #### Output
 

apps/sim/app/api/providers/openrouter/embeddings/models/route.test.ts

@@ -0,0 +1,82 @@
+/**
+ * @vitest-environment node
+ */
+import { createMockRequest } from '@sim/testing'
+import { afterAll, beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockFetch, mockFilterBlacklistedModels, mockIsProviderBlacklisted } = vi.hoisted(() => ({
+  mockFetch: vi.fn(),
+  mockFilterBlacklistedModels: vi.fn(),
+  mockIsProviderBlacklisted: vi.fn(),
+}))
+
+vi.mock('@/providers/utils', () => ({
+  filterBlacklistedModels: mockFilterBlacklistedModels,
+  isProviderBlacklisted: mockIsProviderBlacklisted,
+}))
+
+import { GET } from '@/app/api/providers/openrouter/embeddings/models/route'
+
+const request = () => createMockRequest('GET')
+
+describe('GET /api/providers/openrouter/embeddings/models', () => {
+  beforeEach(() => {
+    vi.clearAllMocks()
+    vi.stubGlobal('fetch', mockFetch)
+    mockIsProviderBlacklisted.mockReturnValue(false)
+    mockFilterBlacklistedModels.mockImplementation((models: string[]) => models)
+  })
+
+  afterAll(() => {
+    vi.unstubAllGlobals()
+  })
+
+  it('returns every unique embedding model with the OpenRouter prefix', async () => {
+    mockFetch.mockResolvedValue({
+      ok: true,
+      status: 200,
+      statusText: 'OK',
+      json: async () => ({
+        data: [
+          { id: 'qwen/qwen3-embedding-8b' },
+          { id: 'openai/text-embedding-3-small' },
+          { id: 'qwen/qwen3-embedding-8b' },
+        ],
+      }),
+    })
+
+    const response = await GET(request(), undefined as never)
+
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({
+      models: ['openrouter/qwen/qwen3-embedding-8b', 'openrouter/openai/text-embedding-3-small'],
+    })
+    expect(mockFetch).toHaveBeenCalledWith(
+      'https://openrouter.ai/api/v1/embeddings/models',
+      expect.objectContaining({ next: { revalidate: 300 } })
+    )
+  })
+
+  it('does not fetch when OpenRouter is blacklisted', async () => {
+    mockIsProviderBlacklisted.mockReturnValue(true)
+
+    const response = await GET(request(), undefined as never)
+
+    expect(response.status).toBe(200)
+    await expect(response.json()).resolves.toEqual({ models: [] })
+    expect(mockFetch).not.toHaveBeenCalled()
+  })
+
+  it('fails fast when OpenRouter rejects the model-list request', async () => {
+    mockFetch.mockResolvedValue({
+      ok: false,
+      status: 503,
+      statusText: 'Service Unavailable',
+    })
+
+    const response = await GET(request(), undefined as never)
+
+    expect(response.status).toBe(500)
+    expect(mockFilterBlacklistedModels).not.toHaveBeenCalled()
+  })
+})

apps/sim/app/api/providers/openrouter/embeddings/models/route.ts

@@ -0,0 +1,40 @@
+import { createLogger } from '@sim/logger'
+import { type NextRequest, NextResponse } from 'next/server'
+import {
+  openRouterEmbeddingModelsUpstreamResponseSchema,
+  providerModelsResponseSchema,
+} from '@/lib/api/contracts/providers'
+import { withRouteHandler } from '@/lib/core/utils/with-route-handler'
+import { toOpenRouterEmbeddingModelId } from '@/lib/embeddings/openrouter-models'
+import { filterBlacklistedModels, isProviderBlacklisted } from '@/providers/utils'
+
+const logger = createLogger('OpenRouterEmbeddingModelsAPI')
+
+export const GET = withRouteHandler(async (_request: NextRequest) => {
+  if (isProviderBlacklisted('openrouter')) {
+    logger.info('OpenRouter provider is blacklisted, returning empty embedding models')
+    return NextResponse.json({ models: [] })
+  }
+
+  const response = await fetch('https://openrouter.ai/api/v1/embeddings/models', {
+    headers: { 'Content-Type': 'application/json' },
+    next: { revalidate: 300 },
+  })
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch OpenRouter embedding models: ${response.status} ${response.statusText}`
+    )
+  }
+
+  const data = openRouterEmbeddingModelsUpstreamResponseSchema.parse(await response.json())
+  const uniqueModels = Array.from(
+    new Set(data.data.map((model) => toOpenRouterEmbeddingModelId(model.id)))
+  )
+  const models = filterBlacklistedModels(uniqueModels)
+
+  logger.info('Successfully fetched OpenRouter embedding models', {
+    count: models.length,
+    filtered: uniqueModels.length - models.length,
+  })
+  return NextResponse.json(providerModelsResponseSchema.parse({ models }))
+})

apps/sim/app/api/tools/embeddings/route.test.ts

@@ -1,24 +1,20 @@
 /**
  * @vitest-environment node
  */
-import {
-  createMockRequest,
-  hybridAuthMockFns,
-  resetEnvFlagsMock,
-  resetEnvMock,
-  setEnv,
-  setEnvFlags,
-} from '@sim/testing'
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-
-const { mockEmbed } = vi.hoisted(() => ({
+import { createMockRequest, hybridAuthMockFns } from '@sim/testing'
+import { beforeEach, describe, expect, it, vi } from 'vitest'
+
+const { mockEmbed, mockEmbedOpenRouter } = vi.hoisted(() => ({
   mockEmbed: vi.fn(),
+  mockEmbedOpenRouter: vi.fn(),
 }))
 
 vi.mock('@/lib/embeddings', async () => {
   const catalog = await import('@/lib/embeddings/catalog')
   return {
     embed: mockEmbed,
+    embedOpenRouter: mockEmbedOpenRouter,
+    DEFAULT_OPENROUTER_EMBEDDING_MODEL: 'openrouter/openai/text-embedding-3-small',
     findEmbeddingModelInfo: catalog.findEmbeddingModelInfo,
     getModelsForProvider: catalog.getModelsForProvider,
     resolveDimensions: catalog.resolveDimensions,
@@ -41,8 +37,6 @@ function post(body: Record<string, unknown>) {
 describe('POST /api/tools/embeddings', () => {
   beforeEach(() => {
     vi.clearAllMocks()
-    setEnvFlags({ isHosted: false })
-    setEnv({ OPENROUTER_API_KEY: undefined })
     hybridAuthMockFns.mockCheckInternalAuth.mockResolvedValue({
       success: true,
       userId: 'user-1',
@@ -56,11 +50,15 @@ describe('POST /api/tools/embeddings', () => {
       pricingId: 'text-embedding-3-small',
       dimensions: 1536,
     })
-  })
-
-  afterEach(() => {
-    resetEnvFlagsMock()
-    resetEnvMock()
+    mockEmbedOpenRouter.mockResolvedValue({
+      embeddings: [[0.1, 0.2]],
+      totalTokens: 3,
+      billableTokens: 0,
+      isBYOK: true,
+      modelName: 'openrouter/qwen/qwen3-embedding-8b',
+      pricingId: 'openrouter/qwen/qwen3-embedding-8b',
+      dimensions: 2,
+    })
   })
 
   it('rejects an unauthenticated caller', async () => {
@@ -134,66 +132,47 @@ describe('POST /api/tools/embeddings', () => {
   it('routes OpenRouter through its transport with an explicit key', async () => {
     const response = await post({
       provider: 'openrouter',
-      model: 'text-embedding-3-large',
+      model: 'openrouter/qwen/qwen3-embedding-8b',
       input: 'hello world',
       apiKey: 'or-test',
-      dimensions: 1024,
     })
 
     expect(response.status).toBe(200)
-    expect(mockEmbed).toHaveBeenCalledWith(
+    expect(mockEmbedOpenRouter).toHaveBeenCalledWith(
       ['hello world'],
       expect.objectContaining({
         apiKey: 'or-test',
-        model: 'text-embedding-3-large',
-        transport: 'openrouter',
-        dimensions: 1024,
+        model: 'openrouter/qwen/qwen3-embedding-8b',
       })
     )
+    expect(mockEmbed).not.toHaveBeenCalled()
     expect((await response.json()).provider).toBe('openrouter')
   })
 
-  it('uses OPENROUTER_API_KEY on self-hosted deployments when the block key is omitted', async () => {
-    setEnv({ OPENROUTER_API_KEY: 'or-environment' })
-
-    const response = await post({
-      provider: 'openrouter',
-      model: 'text-embedding-3-small',
-      input: 'hello world',
-    })
-
-    expect(response.status).toBe(200)
-    expect(mockEmbed).toHaveBeenCalledWith(
-      ['hello world'],
-      expect.objectContaining({ apiKey: 'or-environment', transport: 'openrouter' })
-    )
-  })
-
-  it('rejects OpenRouter without a block or self-hosted environment key', async () => {
+  it('rejects OpenRouter without an explicit key', async () => {
     const response = await post({
       provider: 'openrouter',
-      model: 'text-embedding-3-small',
+      model: 'openrouter/openai/text-embedding-3-small',
       input: 'hello world',
     })
 
     expect(response.status).toBe(400)
-    expect((await response.json()).error).toContain('API key is required for openrouter')
+    expect((await response.json()).error).toContain('apiKey')
     expect(mockEmbed).not.toHaveBeenCalled()
+    expect(mockEmbedOpenRouter).not.toHaveBeenCalled()
   })
 
-  it('does not read OPENROUTER_API_KEY directly on hosted deployments', async () => {
-    setEnvFlags({ isHosted: true })
-    setEnv({ OPENROUTER_API_KEY: 'hosted-platform-key' })
-
+  it('rejects an invalid OpenRouter model id', async () => {
     const response = await post({
       provider: 'openrouter',
-      model: 'text-embedding-3-small',
+      model: 'openrouter/not-qualified',
       input: 'hello world',
+      apiKey: 'or-test',
     })
 
     expect(response.status).toBe(400)
-    expect((await response.json()).error).toContain('API key is required for openrouter')
-    expect(mockEmbed).not.toHaveBeenCalled()
+    expect((await response.json()).error).toContain('Invalid OpenRouter embedding model')
+    expect(mockEmbedOpenRouter).not.toHaveBeenCalled()
   })
 
   it('keeps API keys required for non-OpenRouter providers', async () => {