@elevasis/core 0.7.1 → 0.8.2

package/src/execution/engine/llm/adapters/__tests__/openrouter-adapter.test.ts

@@ -1,563 +1,563 @@
-/**
- * OpenRouter Adapter Tests
- * Verifies OpenRouter adapter configuration, API translation, and options handling
- */
-
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import { OpenRouterAdapter, isOpenRouterModel } from '../server/openrouter'
-import { LLMResponseParseError } from '../../errors'
-import type { LLMGenerateRequest } from '../../types'
-import type { LLMModel } from '../../model-info'
-
-// Mock OpenAI SDK (OpenRouter uses OpenAI SDK with custom baseURL)
-vi.mock('openai', () => {
-  return {
-    default: vi.fn().mockImplementation(() => ({
-      chat: {
-        completions: {
-          create: vi.fn()
-        }
-      }
-    }))
-  }
-})
-
-describe('OpenRouterAdapter', () => {
-  const mockOpenAICreate = vi.fn()
-
-  beforeEach(async () => {
-    vi.clearAllMocks()
-
-    // Get the mock OpenAI constructor
-    const OpenAI = (await import('openai')).default as unknown as { mockImplementation: (fn: () => unknown) => void }
-    OpenAI.mockImplementation(() => ({
-      chat: {
-        completions: {
-          create: mockOpenAICreate
-        }
-      }
-    }))
-  })
-
-  const baseRequest: LLMGenerateRequest = {
-    messages: [
-      { role: 'system', content: 'You are a helpful assistant' },
-      { role: 'user', content: 'Hello' }
-    ],
-    responseSchema: {
-      type: 'object',
-      properties: {
-        response: { type: 'string' }
-      }
-    },
-    maxOutputTokens: 1000
-  }
-
-  const mockOpenRouterResponse = {
-    choices: [
-      {
-        message: {
-          content: JSON.stringify({ response: 'Hello from Claude!' })
-        },
-        finish_reason: 'stop'
-      }
-    ],
-    usage: {
-      prompt_tokens: 15,
-      completion_tokens: 25,
-      total_tokens: 40,
-      cost: 0.00125 // Actual cost from OpenRouter when usage accounting is enabled
-    }
-  }
-
-  describe('isOpenRouterModel', () => {
-    it('returns true for valid OpenRouter models', () => {
-      expect(isOpenRouterModel('openrouter/anthropic/claude-sonnet-4.5')).toBe(true)
-      expect(isOpenRouterModel('openrouter/deepseek/deepseek-v3.2')).toBe(true)
-      expect(isOpenRouterModel('openrouter/x-ai/grok-4.1-fast')).toBe(true)
-    })
-
-    it('returns false for non-OpenRouter models', () => {
-      expect(isOpenRouterModel('gpt-5-mini')).toBe(false)
-      expect(isOpenRouterModel('gpt-5')).toBe(false)
-      expect(isOpenRouterModel('mock')).toBe(false)
-    })
-  })
-
-  describe('Basic Configuration', () => {
-    it('creates adapter with OpenRouter model', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      const response = await adapter.generate(baseRequest)
-
-      expect(response.output).toEqual({ response: 'Hello from Claude!' })
-      expect(response.usage).toEqual({
-        inputTokens: 15,
-        outputTokens: 25,
-        totalTokens: 40
-      })
-      expect(response.cost).toBe(0.00125)
-    })
-
-    it('strips openrouter/ prefix when calling API', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      await adapter.generate(baseRequest)
-
-      const createParams = mockOpenAICreate.mock.calls[0][0]
-      // Model should be stripped of 'openrouter/' prefix
-      expect(createParams.model).toBe('anthropic/claude-sonnet-4.5')
-    })
-
-    it('uses correct OpenRouter baseURL and headers', async () => {
-      // Verify OpenAI SDK was instantiated with OpenRouter config
-      const OpenAI = (await import('openai')).default as unknown as ReturnType<typeof vi.fn>
-
-      new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      // SDK is lazily loaded, so we need to trigger a call to check constructor params
-      // The mock verifies the constructor was called correctly
-      expect(OpenAI).toBeDefined()
-    })
-  })
-
-  describe('Structured Output', () => {
-    it('sends response_format with json_schema and strict mode', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      await adapter.generate(baseRequest)
-
-      const createParams = mockOpenAICreate.mock.calls[0][0]
-      expect(createParams.response_format).toEqual({
-        type: 'json_schema',
-        json_schema: {
-          name: 'llm_response',
-          strict: true,
-          schema: baseRequest.responseSchema
-        }
-      })
-    })
-  })
-
-  describe('OpenRouter-Specific Options', () => {
-    it('always includes usage accounting in extra_body', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/deepseek/deepseek-v3.2'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      await adapter.generate(baseRequest)
-
-      const createParams = mockOpenAICreate.mock.calls[0][0]
-      expect(createParams.extra_body).toEqual({
-        usage: { include: true }
-      })
-    })
-
-    it('passes transforms option via extra_body', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5',
-        modelOptions: {
-          transforms: ['middle-out']
-        }
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      await adapter.generate(baseRequest)
-
-      const createParams = mockOpenAICreate.mock.calls[0][0]
-      expect(createParams.extra_body).toEqual({
-        usage: { include: true },
-        transforms: ['middle-out']
-      })
-    })
-
-    it('passes route option via extra_body', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5',
-        modelOptions: {
-          route: 'fallback'
-        }
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      await adapter.generate(baseRequest)
-
-      const createParams = mockOpenAICreate.mock.calls[0][0]
-      expect(createParams.extra_body).toEqual({
-        usage: { include: true },
-        route: 'fallback'
-      })
-    })
-
-    it('passes both transforms and route options', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5',
-        modelOptions: {
-          transforms: ['middle-out'],
-          route: 'fallback'
-        }
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      await adapter.generate(baseRequest)
-
-      const createParams = mockOpenAICreate.mock.calls[0][0]
-      expect(createParams.extra_body).toEqual({
-        usage: { include: true },
-        transforms: ['middle-out'],
-        route: 'fallback'
-      })
-    })
-
-    it('handles empty model options object', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/deepseek/deepseek-v3.2',
-        modelOptions: {}
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      await adapter.generate(baseRequest)
-
-      const createParams = mockOpenAICreate.mock.calls[0][0]
-      // Should still have usage accounting even with empty modelOptions
-      expect(createParams.extra_body).toEqual({
-        usage: { include: true }
-      })
-    })
-
-    it('extracts cost from response when available', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      const response = await adapter.generate(baseRequest)
-
-      expect(response.cost).toBe(0.00125)
-    })
-
-    it('returns undefined cost when not present in response', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      // Response without cost field
-      mockOpenAICreate.mockResolvedValueOnce({
-        choices: [
-          {
-            message: {
-              content: JSON.stringify({ response: 'Hello!' })
-            },
-            finish_reason: 'stop'
-          }
-        ],
-        usage: {
-          prompt_tokens: 10,
-          completion_tokens: 20,
-          total_tokens: 30
-          // No cost field
-        }
-      })
-
-      const response = await adapter.generate(baseRequest)
-
-      expect(response.cost).toBeUndefined()
-      expect(response.usage).toBeDefined()
-    })
-  })
-
-  describe('Standard Parameters', () => {
-    it('passes temperature when specified', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      await adapter.generate({
-        ...baseRequest,
-        temperature: 0.7
-      })
-
-      const createParams = mockOpenAICreate.mock.calls[0][0]
-      expect(createParams.temperature).toBe(0.7)
-    })
-
-    it('passes topP when specified', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      await adapter.generate({
-        ...baseRequest,
-        topP: 0.9
-      })
-
-      const createParams = mockOpenAICreate.mock.calls[0][0]
-      expect(createParams.top_p).toBe(0.9)
-    })
-
-    it('passes maxOutputTokens as max_tokens', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      await adapter.generate({
-        ...baseRequest,
-        maxOutputTokens: 4000
-      })
-
-      const createParams = mockOpenAICreate.mock.calls[0][0]
-      expect(createParams.max_tokens).toBe(4000)
-    })
-
-    it('combines all parameters correctly', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5',
-        modelOptions: {
-          route: 'fallback'
-        }
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      await adapter.generate({
-        ...baseRequest,
-        temperature: 0.8,
-        topP: 0.95,
-        maxOutputTokens: 8000
-      })
-
-      const createParams = mockOpenAICreate.mock.calls[0][0]
-      expect(createParams.model).toBe('anthropic/claude-sonnet-4.5')
-      expect(createParams.temperature).toBe(0.8)
-      expect(createParams.top_p).toBe(0.95)
-      expect(createParams.max_tokens).toBe(8000)
-      expect(createParams.extra_body).toEqual({
-        usage: { include: true },
-        route: 'fallback'
-      })
-    })
-  })
-
-  describe('Error Handling', () => {
-    it('throws error when no response from OpenRouter', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce({
-        choices: [],
-        usage: null
-      })
-
-      await expect(adapter.generate(baseRequest)).rejects.toThrow('No response from OpenRouter')
-    })
-
-    it('throws TokenLimitExceededError when finish_reason is length', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce({
-        choices: [
-          {
-            message: { content: '{}' },
-            finish_reason: 'length'
-          }
-        ],
-        usage: {
-          prompt_tokens: 1000,
-          completion_tokens: 4000,
-          total_tokens: 5000
-        }
-      })
-
-      await expect(adapter.generate(baseRequest)).rejects.toThrow('LLM token limit exceeded')
-    })
-
-    it('re-throws API errors', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      const apiError = new Error('Rate limit exceeded')
-      Object.assign(apiError, { status: 429 })
-
-      mockOpenAICreate.mockRejectedValueOnce(apiError)
-
-      await expect(adapter.generate(baseRequest)).rejects.toThrow('Rate limit exceeded')
-    })
-  })
-
-  describe('JSON Parse Error Handling', () => {
-    it('throws LLMResponseParseError when response is invalid JSON', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      const invalidJsonResponse = {
-        choices: [
-          {
-            message: {
-              content: '{"response": "incomplete json' // Invalid JSON - unterminated string
-            },
-            finish_reason: 'stop'
-          }
-        ],
-        usage: {
-          prompt_tokens: 10,
-          completion_tokens: 20,
-          total_tokens: 30
-        }
-      }
-
-      mockOpenAICreate.mockResolvedValueOnce(invalidJsonResponse)
-
-      await expect(adapter.generate(baseRequest)).rejects.toThrow(LLMResponseParseError)
-    })
-
-    it('includes truncated raw content in LLMResponseParseError context', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      const invalidJsonResponse = {
-        choices: [
-          {
-            message: {
-              content: '{"response": "incomplete'
-            },
-            finish_reason: 'stop'
-          }
-        ],
-        usage: {
-          prompt_tokens: 10,
-          completion_tokens: 20,
-          total_tokens: 30
-        }
-      }
-
-      mockOpenAICreate.mockResolvedValueOnce(invalidJsonResponse)
-
-      try {
-        await adapter.generate(baseRequest)
-        expect.fail('Should have thrown')
-      } catch (error) {
-        expect(error).toBeInstanceOf(LLMResponseParseError)
-        const parseError = error as LLMResponseParseError
-        expect(parseError.context).toHaveProperty('rawContent')
-        expect(parseError.context).toHaveProperty('parseError')
-        expect(parseError.message).toContain('Failed to parse LLM response as JSON')
-      }
-    })
-
-    it('parses valid JSON successfully', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      const result = await adapter.generate(baseRequest)
-      expect(result.output).toEqual({ response: 'Hello from Claude!' })
-    })
-  })
-
-  describe('Multiple Models', () => {
-    it('works with different OpenRouter models', async () => {
-      const models: LLMModel[] = [
-        'openrouter/anthropic/claude-sonnet-4.5',
-        'openrouter/deepseek/deepseek-v3.2',
-        'openrouter/x-ai/grok-4.1-fast'
-      ]
-
-      for (const model of models) {
-        const adapter = new OpenRouterAdapter({
-          apiKey: 'sk-or-v1-test-key',
-          model
-        })
-
-        mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-        const response = await adapter.generate(baseRequest)
-        expect(response.output).toBeDefined()
-
-        const createParams = mockOpenAICreate.mock.calls[mockOpenAICreate.mock.calls.length - 1][0]
-        expect(createParams.model).toBe(model.replace('openrouter/', ''))
-      }
-    })
-  })
-
-  describe('Backward Compatibility', () => {
-    it('works with existing LLM request format', async () => {
-      const adapter = new OpenRouterAdapter({
-        apiKey: 'sk-or-v1-test-key',
-        model: 'openrouter/anthropic/claude-sonnet-4.5'
-      })
-
-      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
-
-      // Use the standard LLMGenerateRequest format
-      const response = await adapter.generate({
-        messages: [{ role: 'user', content: 'Test message' }],
-        responseSchema: {
-          type: 'object',
-          properties: {
-            result: { type: 'string' }
-          }
-        },
-        maxOutputTokens: 2000
-      })
-
-      expect(response.output).toBeDefined()
-      expect(response.usage).toBeDefined()
-    })
-  })
-})
+/**
+ * OpenRouter Adapter Tests
+ * Verifies OpenRouter adapter configuration, API translation, and options handling
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { OpenRouterAdapter, isOpenRouterModel } from '../server/openrouter'
+import { LLMResponseParseError } from '../../errors'
+import type { LLMGenerateRequest } from '../../types'
+import type { LLMModel } from '../../model-info'
+
+// Mock OpenAI SDK (OpenRouter uses OpenAI SDK with custom baseURL)
+vi.mock('openai', () => {
+  return {
+    default: vi.fn().mockImplementation(() => ({
+      chat: {
+        completions: {
+          create: vi.fn()
+        }
+      }
+    }))
+  }
+})
+
+describe('OpenRouterAdapter', () => {
+  const mockOpenAICreate = vi.fn()
+
+  beforeEach(async () => {
+    vi.clearAllMocks()
+
+    // Get the mock OpenAI constructor
+    const OpenAI = (await import('openai')).default as unknown as { mockImplementation: (fn: () => unknown) => void }
+    OpenAI.mockImplementation(() => ({
+      chat: {
+        completions: {
+          create: mockOpenAICreate
+        }
+      }
+    }))
+  })
+
+  const baseRequest: LLMGenerateRequest = {
+    messages: [
+      { role: 'system', content: 'You are a helpful assistant' },
+      { role: 'user', content: 'Hello' }
+    ],
+    responseSchema: {
+      type: 'object',
+      properties: {
+        response: { type: 'string' }
+      }
+    },
+    maxOutputTokens: 1000
+  }
+
+  const mockOpenRouterResponse = {
+    choices: [
+      {
+        message: {
+          content: JSON.stringify({ response: 'Hello from Claude!' })
+        },
+        finish_reason: 'stop'
+      }
+    ],
+    usage: {
+      prompt_tokens: 15,
+      completion_tokens: 25,
+      total_tokens: 40,
+      cost: 0.00125 // Actual cost from OpenRouter when usage accounting is enabled
+    }
+  }
+
+  describe('isOpenRouterModel', () => {
+    it('returns true for valid OpenRouter models', () => {
+      expect(isOpenRouterModel('openrouter/anthropic/claude-sonnet-4.5')).toBe(true)
+      expect(isOpenRouterModel('openrouter/deepseek/deepseek-v3.2')).toBe(true)
+      expect(isOpenRouterModel('openrouter/x-ai/grok-4.1-fast')).toBe(true)
+    })
+
+    it('returns false for non-OpenRouter models', () => {
+      expect(isOpenRouterModel('gpt-5-mini')).toBe(false)
+      expect(isOpenRouterModel('gpt-5')).toBe(false)
+      expect(isOpenRouterModel('mock')).toBe(false)
+    })
+  })
+
+  describe('Basic Configuration', () => {
+    it('creates adapter with OpenRouter model', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      const response = await adapter.generate(baseRequest)
+
+      expect(response.output).toEqual({ response: 'Hello from Claude!' })
+      expect(response.usage).toEqual({
+        inputTokens: 15,
+        outputTokens: 25,
+        totalTokens: 40
+      })
+      expect(response.cost).toBe(0.00125)
+    })
+
+    it('strips openrouter/ prefix when calling API', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      await adapter.generate(baseRequest)
+
+      const createParams = mockOpenAICreate.mock.calls[0][0]
+      // Model should be stripped of 'openrouter/' prefix
+      expect(createParams.model).toBe('anthropic/claude-sonnet-4.5')
+    })
+
+    it('uses correct OpenRouter baseURL and headers', async () => {
+      // Verify OpenAI SDK was instantiated with OpenRouter config
+      const OpenAI = (await import('openai')).default as unknown as ReturnType<typeof vi.fn>
+
+      new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      // SDK is lazily loaded, so we need to trigger a call to check constructor params
+      // The mock verifies the constructor was called correctly
+      expect(OpenAI).toBeDefined()
+    })
+  })
+
+  describe('Structured Output', () => {
+    it('sends response_format with json_schema and strict mode', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      await adapter.generate(baseRequest)
+
+      const createParams = mockOpenAICreate.mock.calls[0][0]
+      expect(createParams.response_format).toEqual({
+        type: 'json_schema',
+        json_schema: {
+          name: 'llm_response',
+          strict: true,
+          schema: baseRequest.responseSchema
+        }
+      })
+    })
+  })
+
+  describe('OpenRouter-Specific Options', () => {
+    it('always includes usage accounting in extra_body', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/deepseek/deepseek-v3.2'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      await adapter.generate(baseRequest)
+
+      const createParams = mockOpenAICreate.mock.calls[0][0]
+      expect(createParams.extra_body).toEqual({
+        usage: { include: true }
+      })
+    })
+
+    it('passes transforms option via extra_body', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5',
+        modelOptions: {
+          transforms: ['middle-out']
+        }
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      await adapter.generate(baseRequest)
+
+      const createParams = mockOpenAICreate.mock.calls[0][0]
+      expect(createParams.extra_body).toEqual({
+        usage: { include: true },
+        transforms: ['middle-out']
+      })
+    })
+
+    it('passes route option via extra_body', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5',
+        modelOptions: {
+          route: 'fallback'
+        }
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      await adapter.generate(baseRequest)
+
+      const createParams = mockOpenAICreate.mock.calls[0][0]
+      expect(createParams.extra_body).toEqual({
+        usage: { include: true },
+        route: 'fallback'
+      })
+    })
+
+    it('passes both transforms and route options', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5',
+        modelOptions: {
+          transforms: ['middle-out'],
+          route: 'fallback'
+        }
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      await adapter.generate(baseRequest)
+
+      const createParams = mockOpenAICreate.mock.calls[0][0]
+      expect(createParams.extra_body).toEqual({
+        usage: { include: true },
+        transforms: ['middle-out'],
+        route: 'fallback'
+      })
+    })
+
+    it('handles empty model options object', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/deepseek/deepseek-v3.2',
+        modelOptions: {}
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      await adapter.generate(baseRequest)
+
+      const createParams = mockOpenAICreate.mock.calls[0][0]
+      // Should still have usage accounting even with empty modelOptions
+      expect(createParams.extra_body).toEqual({
+        usage: { include: true }
+      })
+    })
+
+    it('extracts cost from response when available', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      const response = await adapter.generate(baseRequest)
+
+      expect(response.cost).toBe(0.00125)
+    })
+
+    it('returns undefined cost when not present in response', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      // Response without cost field
+      mockOpenAICreate.mockResolvedValueOnce({
+        choices: [
+          {
+            message: {
+              content: JSON.stringify({ response: 'Hello!' })
+            },
+            finish_reason: 'stop'
+          }
+        ],
+        usage: {
+          prompt_tokens: 10,
+          completion_tokens: 20,
+          total_tokens: 30
+          // No cost field
+        }
+      })
+
+      const response = await adapter.generate(baseRequest)
+
+      expect(response.cost).toBeUndefined()
+      expect(response.usage).toBeDefined()
+    })
+  })
+
+  describe('Standard Parameters', () => {
+    it('passes temperature when specified', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      await adapter.generate({
+        ...baseRequest,
+        temperature: 0.7
+      })
+
+      const createParams = mockOpenAICreate.mock.calls[0][0]
+      expect(createParams.temperature).toBe(0.7)
+    })
+
+    it('passes topP when specified', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      await adapter.generate({
+        ...baseRequest,
+        topP: 0.9
+      })
+
+      const createParams = mockOpenAICreate.mock.calls[0][0]
+      expect(createParams.top_p).toBe(0.9)
+    })
+
+    it('passes maxOutputTokens as max_tokens', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      await adapter.generate({
+        ...baseRequest,
+        maxOutputTokens: 4000
+      })
+
+      const createParams = mockOpenAICreate.mock.calls[0][0]
+      expect(createParams.max_tokens).toBe(4000)
+    })
+
+    it('combines all parameters correctly', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5',
+        modelOptions: {
+          route: 'fallback'
+        }
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      await adapter.generate({
+        ...baseRequest,
+        temperature: 0.8,
+        topP: 0.95,
+        maxOutputTokens: 8000
+      })
+
+      const createParams = mockOpenAICreate.mock.calls[0][0]
+      expect(createParams.model).toBe('anthropic/claude-sonnet-4.5')
+      expect(createParams.temperature).toBe(0.8)
+      expect(createParams.top_p).toBe(0.95)
+      expect(createParams.max_tokens).toBe(8000)
+      expect(createParams.extra_body).toEqual({
+        usage: { include: true },
+        route: 'fallback'
+      })
+    })
+  })
+
+  describe('Error Handling', () => {
+    it('throws error when no response from OpenRouter', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce({
+        choices: [],
+        usage: null
+      })
+
+      await expect(adapter.generate(baseRequest)).rejects.toThrow('No response from OpenRouter')
+    })
+
+    it('throws TokenLimitExceededError when finish_reason is length', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce({
+        choices: [
+          {
+            message: { content: '{}' },
+            finish_reason: 'length'
+          }
+        ],
+        usage: {
+          prompt_tokens: 1000,
+          completion_tokens: 4000,
+          total_tokens: 5000
+        }
+      })
+
+      await expect(adapter.generate(baseRequest)).rejects.toThrow('LLM token limit exceeded')
+    })
+
+    it('re-throws API errors', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      const apiError = new Error('Rate limit exceeded')
+      Object.assign(apiError, { status: 429 })
+
+      mockOpenAICreate.mockRejectedValueOnce(apiError)
+
+      await expect(adapter.generate(baseRequest)).rejects.toThrow('Rate limit exceeded')
+    })
+  })
+
+  describe('JSON Parse Error Handling', () => {
+    it('throws LLMResponseParseError when response is invalid JSON', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      const invalidJsonResponse = {
+        choices: [
+          {
+            message: {
+              content: '{"response": "incomplete json' // Invalid JSON - unterminated string
+            },
+            finish_reason: 'stop'
+          }
+        ],
+        usage: {
+          prompt_tokens: 10,
+          completion_tokens: 20,
+          total_tokens: 30
+        }
+      }
+
+      mockOpenAICreate.mockResolvedValueOnce(invalidJsonResponse)
+
+      await expect(adapter.generate(baseRequest)).rejects.toThrow(LLMResponseParseError)
+    })
+
+    it('includes truncated raw content in LLMResponseParseError context', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      const invalidJsonResponse = {
+        choices: [
+          {
+            message: {
+              content: '{"response": "incomplete'
+            },
+            finish_reason: 'stop'
+          }
+        ],
+        usage: {
+          prompt_tokens: 10,
+          completion_tokens: 20,
+          total_tokens: 30
+        }
+      }
+
+      mockOpenAICreate.mockResolvedValueOnce(invalidJsonResponse)
+
+      try {
+        await adapter.generate(baseRequest)
+        expect.fail('Should have thrown')
+      } catch (error) {
+        expect(error).toBeInstanceOf(LLMResponseParseError)
+        const parseError = error as LLMResponseParseError
+        expect(parseError.context).toHaveProperty('rawContent')
+        expect(parseError.context).toHaveProperty('parseError')
+        expect(parseError.message).toContain('Failed to parse LLM response as JSON')
+      }
+    })
+
+    it('parses valid JSON successfully', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      const result = await adapter.generate(baseRequest)
+      expect(result.output).toEqual({ response: 'Hello from Claude!' })
+    })
+  })
+
+  describe('Multiple Models', () => {
+    it('works with different OpenRouter models', async () => {
+      const models: LLMModel[] = [
+        'openrouter/anthropic/claude-sonnet-4.5',
+        'openrouter/deepseek/deepseek-v3.2',
+        'openrouter/x-ai/grok-4.1-fast'
+      ]
+
+      for (const model of models) {
+        const adapter = new OpenRouterAdapter({
+          apiKey: 'sk-or-v1-test-key',
+          model
+        })
+
+        mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+        const response = await adapter.generate(baseRequest)
+        expect(response.output).toBeDefined()
+
+        const createParams = mockOpenAICreate.mock.calls[mockOpenAICreate.mock.calls.length - 1][0]
+        expect(createParams.model).toBe(model.replace('openrouter/', ''))
+      }
+    })
+  })
+
+  describe('Backward Compatibility', () => {
+    it('works with existing LLM request format', async () => {
+      const adapter = new OpenRouterAdapter({
+        apiKey: 'sk-or-v1-test-key',
+        model: 'openrouter/anthropic/claude-sonnet-4.5'
+      })
+
+      mockOpenAICreate.mockResolvedValueOnce(mockOpenRouterResponse)
+
+      // Use the standard LLMGenerateRequest format
+      const response = await adapter.generate({
+        messages: [{ role: 'user', content: 'Test message' }],
+        responseSchema: {
+          type: 'object',
+          properties: {
+            result: { type: 'string' }
+          }
+        },
+        maxOutputTokens: 2000
+      })
+
+      expect(response.output).toBeDefined()
+      expect(response.usage).toBeDefined()
+    })
+  })
+})