@open-mercato/ai-assistant 0.10.1-develop.7688.1.8bbd70dcdf → 0.10.1-develop.7690.1.9d41ec4115

package/src/modules/ai_assistant/lib/__tests__/decision-openrouter-adapter.test.ts

@@ -0,0 +1,321 @@
+import type { EnvLookup } from '@open-mercato/shared/lib/ai/llm-provider'
+import type { DecisionRequest } from '@open-mercato/shared/lib/ai/decision-model'
+import { createOpenRouterDecisionAdapter } from '../decision-adapters/openrouter'
+import { DecisionModelError } from '../decision-model-schemas'
+
+const API_KEY = 'sk-or-test-key'
+const BASE_ENV: EnvLookup = { OPENROUTER_API_KEY: API_KEY }
+
+const originalFetch = global.fetch
+let fetchMock: jest.Mock
+
+function jsonResponse(status: number, body: unknown): Response {
+  return new Response(typeof body === 'string' ? body : JSON.stringify(body), {
+    status,
+    headers: { 'Content-Type': 'application/json' },
+  })
+}
+
+function fullRequest(): DecisionRequest {
+  return {
+    state: { ticket: { subject: 'Refund please', amount: 42 } },
+    questions: {
+      route: {
+        type: 'choice',
+        instructions: 'Pick the queue',
+        options: [
+          { key: '10', criteria: 'Ten queue' },
+          { key: '2', criteria: 'Two queue' },
+          { key: 'billing', criteria: 'Billing queue' },
+        ],
+      },
+      urgency: {
+        type: 'score',
+        instructions: 'Rate urgency',
+        levels: ['low', 'medium', 'high'],
+      },
+      spam: {
+        type: 'binary',
+        instructions: 'Is it spam?',
+        criteria: { true: 'Spam', false: 'Legit' },
+      },
+    },
+    sessionId: 'wf-instance-1',
+  }
+}
+
+function successBody(overrides: Record<string, unknown> = {}) {
+  return {
+    model: 'typesafe/jev-1.13',
+    answers: {
+      route: {
+        choice: 'billing',
+        confidence: 0.7,
+        probabilities: { billing: 0.7, '2': 0.2, '10': 0.1 },
+      },
+      urgency: {
+        score: 1.5,
+        confidence: 0.6,
+        probabilities: [0.1, 0.3, 0.6],
+        legend: ['low', 'medium', 'high'],
+      },
+      spam: { noul: 0.05 },
+      ...overrides,
+    },
+    usage: { input_tokens: 120, output_tokens: 3, cost: 0.0004 },
+  }
+}
+
+async function decide(request: DecisionRequest = fullRequest(), env: EnvLookup = BASE_ENV) {
+  const adapter = createOpenRouterDecisionAdapter()
+  return adapter.decide(request, { modelId: 'typesafe/jev-1.13', env, signal: new AbortController().signal })
+}
+
+async function decideError(request?: DecisionRequest): Promise<DecisionModelError> {
+  try {
+    await decide(request)
+  } catch (error) {
+    if (error instanceof DecisionModelError) return error
+    throw error
+  }
+  throw new Error('[internal] expected decide to throw')
+}
+
+function sentInit(): RequestInit {
+  const call = fetchMock.mock.calls[0]
+  return call[1] as RequestInit
+}
+
+function sentUrl(): string {
+  return String(fetchMock.mock.calls[0][0])
+}
+
+function sentBodyText(): string {
+  return String(sentInit().body)
+}
+
+beforeEach(() => {
+  fetchMock = jest.fn()
+  global.fetch = fetchMock as unknown as typeof fetch
+})
+
+afterEach(() => {
+  global.fetch = originalFetch
+})
+
+describe('createOpenRouterDecisionAdapter', () => {
+  describe('isConfigured', () => {
+    const adapter = createOpenRouterDecisionAdapter()
+
+    it('exposes the openrouter id', () => {
+      expect(adapter.id).toBe('openrouter')
+    })
+
+    it('is configured when OPENROUTER_API_KEY is set', () => {
+      expect(adapter.isConfigured({ OPENROUTER_API_KEY: API_KEY })).toBe(true)
+    })
+
+    it('is not configured when the key is missing or blank', () => {
+      expect(adapter.isConfigured({})).toBe(false)
+      expect(adapter.isConfigured({ OPENROUTER_API_KEY: '   ' })).toBe(false)
+    })
+  })
+
+  describe('request mapping', () => {
+    beforeEach(() => {
+      fetchMock.mockResolvedValue(jsonResponse(200, successBody()))
+    })
+
+    it('posts to the default base URL with the bearer key', async () => {
+      await decide()
+      expect(sentUrl()).toBe('https://openrouter.ai/api/alpha/decisions')
+      const init = sentInit()
+      expect(init.method).toBe('POST')
+      expect(init.headers).toEqual({
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${API_KEY}`,
+      })
+      expect(init.signal).toBeInstanceOf(AbortSignal)
+    })
+
+    it('uses OM_DECISION_OPENROUTER_BASE_URL with trailing slashes stripped', async () => {
+      await decide(fullRequest(), { ...BASE_ENV, OM_DECISION_OPENROUTER_BASE_URL: ' https://proxy.test/api/ ' })
+      expect(sentUrl()).toBe('https://proxy.test/api/alpha/decisions')
+    })
+
+    it('ignores OPENROUTER_BASE_URL (the LLM preset base)', async () => {
+      await decide(fullRequest(), { ...BASE_ENV, OPENROUTER_BASE_URL: 'https://example.test/api/v1' })
+      expect(sentUrl()).toBe('https://openrouter.ai/api/alpha/decisions')
+    })
+
+    it('keeps choice criteria in option insertion order, including integer-like keys', async () => {
+      await decide()
+      expect(sentBodyText()).toContain('"criteria":{"10":"Ten queue","2":"Two queue","billing":"Billing queue"}')
+    })
+
+    it('maps all three question types, model, state and session_id', async () => {
+      await decide()
+      const body = JSON.parse(sentBodyText())
+      expect(body.model).toBe('typesafe/jev-1.13')
+      expect(body.state).toEqual({ ticket: { subject: 'Refund please', amount: 42 } })
+      expect(body.session_id).toBe('wf-instance-1')
+      expect(body.questions.route.type).toBe('choice')
+      expect(body.questions.route.instructions).toBe('Pick the queue')
+      expect(body.questions.urgency).toEqual({
+        type: 'score',
+        instructions: 'Rate urgency',
+        criteria: ['low', 'medium', 'high'],
+      })
+      expect(body.questions.spam).toEqual({
+        type: 'noul',
+        instructions: 'Is it spam?',
+        criteria: { true: 'Spam', false: 'Legit' },
+      })
+      expect(body).not.toHaveProperty('user')
+    })
+
+    it('omits session_id when the request has none', async () => {
+      const request = fullRequest()
+      delete request.sessionId
+      await decide(request)
+      const body = JSON.parse(sentBodyText())
+      expect(body).not.toHaveProperty('session_id')
+      expect(body).not.toHaveProperty('user')
+    })
+  })
+
+  describe('response mapping', () => {
+    it('maps choice probabilities in request order', async () => {
+      fetchMock.mockResolvedValue(jsonResponse(200, successBody()))
+      const result = await decide()
+      expect(result.answers.route).toEqual({
+        type: 'choice',
+        value: 'billing',
+        probabilities: [
+          { key: '10', probability: 0.1 },
+          { key: '2', probability: 0.2 },
+          { key: 'billing', probability: 0.7 },
+        ],
+        confidence: 0.7,
+      })
+    })
+
+    it('maps score probabilities given as an array', async () => {
+      fetchMock.mockResolvedValue(jsonResponse(200, successBody()))
+      const result = await decide()
+      const answer = result.answers.urgency
+      if (answer.type !== 'score') throw new Error('[internal] expected a score answer')
+      expect(answer.level).toBe(2)
+      expect(answer.value).toBeCloseTo(1.5)
+      expect(answer.probabilities).toEqual([
+        { level: 0, probability: 0.1 },
+        { level: 1, probability: 0.3 },
+        { level: 2, probability: 0.6 },
+      ])
+      expect(answer.confidence).toBe(0.6)
+    })
+
+    it('maps score probabilities given as an object keyed by level index', async () => {
+      fetchMock.mockResolvedValue(jsonResponse(200, successBody({
+        urgency: { score: 0.4, confidence: 0.7, probabilities: { '2': 0.1, '0': 0.7, '1': 0.2 }, legend: {} },
+      })))
+      const result = await decide()
+      const answer = result.answers.urgency
+      if (answer.type !== 'score') throw new Error('[internal] expected a score answer')
+      expect(answer.level).toBe(0)
+      expect(answer.probabilities).toEqual([
+        { level: 0, probability: expect.closeTo(0.7) },
+        { level: 1, probability: expect.closeTo(0.2) },
+        { level: 2, probability: expect.closeTo(0.1) },
+      ])
+    })
+
+    it('maps noul to a binary probability', async () => {
+      fetchMock.mockResolvedValue(jsonResponse(200, successBody()))
+      const result = await decide()
+      expect(result.answers.spam).toEqual({ type: 'binary', probability: 0.05 })
+    })
+
+    it('maps provider, model and usage', async () => {
+      fetchMock.mockResolvedValue(jsonResponse(200, successBody()))
+      const result = await decide()
+      expect(result.provider).toBe('openrouter')
+      expect(result.model).toBe('typesafe/jev-1.13')
+      expect(result.usage).toEqual({ inputTokens: 120, outputTokens: 3, costUsd: 0.0004 })
+      expect(result.durationMs).toBeGreaterThanOrEqual(0)
+    })
+
+    it('returns null usage and the requested model when the vendor omits them', async () => {
+      const body: Record<string, unknown> = successBody()
+      delete body.usage
+      delete body.model
+      fetchMock.mockResolvedValue(jsonResponse(200, body))
+      const result = await decide()
+      expect(result.model).toBe('typesafe/jev-1.13')
+      expect(result.usage).toEqual({ inputTokens: null, outputTokens: null, costUsd: null })
+    })
+
+    it('rejects an unknown key in choice probabilities as invalid_response', async () => {
+      fetchMock.mockResolvedValue(jsonResponse(200, successBody({
+        route: {
+          choice: 'billing',
+          confidence: 0.7,
+          probabilities: { billing: 0.7, '2': 0.2, '10': 0.05, shipping: 0.05 },
+        },
+      })))
+      const error = await decideError()
+      expect(error.code).toBe('invalid_response')
+    })
+
+    it('rejects an answer whose shape cannot be mapped as invalid_response', async () => {
+      fetchMock.mockResolvedValue(jsonResponse(200, successBody({ spam: { choice: 'yes' } })))
+      const error = await decideError()
+      expect(error.code).toBe('invalid_response')
+    })
+
+    it('treats an unparseable 2xx body as provider_error', async () => {
+      fetchMock.mockResolvedValue(new Response('<html>oops</html>', { status: 200 }))
+      const error = await decideError()
+      expect(error.code).toBe('provider_error')
+      expect(error.httpStatus).toBeUndefined()
+    })
+  })
+
+  describe('HTTP error mapping', () => {
+    it.each([
+      [400, 'invalid_request'],
+      [401, 'auth'],
+      [402, 'insufficient_credits'],
+      [403, 'auth'],
+      [404, 'unavailable'],
+      [413, 'payload_too_large'],
+      [422, 'invalid_request'],
+      [429, 'rate_limited'],
+      [500, 'provider_error'],
+      [524, 'timeout'],
+      [529, 'provider_error'],
+    ])('maps HTTP %i to %s', async (status, code) => {
+      fetchMock.mockResolvedValue(jsonResponse(status, { error: { code: 'vendor_code', message: 'secret vendor detail' } }))
+      const error = await decideError()
+      expect(error.code).toBe(code)
+      expect(error.httpStatus).toBe(status)
+      expect(error.message).toContain('vendor_code')
+      expect(error.message).not.toContain('secret vendor detail')
+      expect(error.message).not.toContain(API_KEY)
+      expect(error.message).not.toContain('Refund please')
+    })
+
+    it('tolerates an unparseable error body', async () => {
+      fetchMock.mockResolvedValue(new Response('not json', { status: 503 }))
+      const error = await decideError()
+      expect(error.code).toBe('provider_error')
+      expect(error.httpStatus).toBe(503)
+    })
+  })
+
+  it('rethrows fetch rejections unchanged', async () => {
+    const abortError = new DOMException('The operation was aborted.', 'AbortError')
+    fetchMock.mockRejectedValue(abortError)
+    await expect(decide()).rejects.toBe(abortError)
+  })
+})

package/src/modules/ai_assistant/lib/decision-adapters/fixture.ts

@@ -0,0 +1,95 @@
+import type {
+  DecisionModelAdapter,
+  DecisionQuestion,
+  DecisionRequest,
+  DecisionResult,
+} from '@open-mercato/shared/lib/ai/decision-model'
+import { normalizeDecisionAnswers, type RawDecisionAnswer } from '../decision-model-schemas'
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
+}
+
+function containsWholeWord(haystack: string, word: string): boolean {
+  const pattern = new RegExp(`(^|[^A-Za-z0-9_-])${escapeRegExp(word)}($|[^A-Za-z0-9_-])`, 'i')
+  return pattern.test(haystack)
+}
+
+function serializeState(state: unknown): string {
+  return JSON.stringify(state) ?? ''
+}
+
+function answerChoice(
+  question: Extract<DecisionQuestion, { type: 'choice' }>,
+  serializedState: string,
+): RawDecisionAnswer {
+  const matched = question.options.find((option) => containsWholeWord(serializedState, option.key))
+  if (matched) {
+    return {
+      type: 'choice',
+      value: matched.key,
+      probabilities: question.options.map((option) => ({
+        key: option.key,
+        probability: option.key === matched.key ? 1 : 0,
+      })),
+      confidence: 1,
+    }
+  }
+  const uniform = 1 / question.options.length
+  return {
+    type: 'choice',
+    value: question.options[0].key,
+    probabilities: question.options.map((option) => ({ key: option.key, probability: uniform })),
+    confidence: uniform,
+  }
+}
+
+function answerScore(question: Extract<DecisionQuestion, { type: 'score' }>): RawDecisionAnswer {
+  const uniform = 1 / question.levels.length
+  return {
+    type: 'score',
+    probabilities: question.levels.map((_, level) => ({ level, probability: uniform })),
+    confidence: uniform,
+  }
+}
+
+function answerQuestion(question: DecisionQuestion, serializedState: string): RawDecisionAnswer {
+  switch (question.type) {
+    case 'choice':
+      return answerChoice(question, serializedState)
+    case 'score':
+      return answerScore(question)
+    case 'binary':
+      return { type: 'binary', probability: 0.5 }
+  }
+}
+
+/**
+ * Deterministic, vendor-free decision adapter for tests and local
+ * development (spec D9). Registration is gated by the registry, not here.
+ */
+export function createFixtureDecisionAdapter(): DecisionModelAdapter {
+  return {
+    id: 'fixture',
+    isConfigured: () => true,
+    async decide(request: DecisionRequest, options): Promise<DecisionResult> {
+      if (options.signal.aborted) {
+        throw options.signal.reason
+      }
+      const startedAt = Date.now()
+      const serializedState = serializeState(request.state)
+      const raw: Record<string, RawDecisionAnswer> = {}
+      for (const [questionName, question] of Object.entries(request.questions)) {
+        raw[questionName] = answerQuestion(question, serializedState)
+      }
+      const answers = normalizeDecisionAnswers(request, raw)
+      return {
+        answers,
+        provider: 'fixture',
+        model: options.modelId,
+        usage: { inputTokens: null, outputTokens: null, costUsd: null },
+        durationMs: Date.now() - startedAt,
+      }
+    },
+  }
+}

package/src/modules/ai_assistant/lib/decision-adapters/openrouter.ts

@@ -0,0 +1,267 @@
+import { z } from 'zod'
+import type { EnvLookup } from '@open-mercato/shared/lib/ai/llm-provider'
+import type {
+  DecisionErrorCode,
+  DecisionModelAdapter,
+  DecisionQuestion,
+  DecisionRequest,
+  DecisionResult,
+} from '@open-mercato/shared/lib/ai/decision-model'
+import { DecisionModelError, normalizeDecisionAnswers, type RawDecisionAnswer } from '../decision-model-schemas'
+
+const DEFAULT_BASE_URL = 'https://openrouter.ai/api'
+const API_KEY_ENV = 'OPENROUTER_API_KEY'
+const BASE_URL_ENV = 'OM_DECISION_OPENROUTER_BASE_URL'
+const VENDOR_ERROR_CODE_PATTERN = /^[A-Za-z0-9_.-]{1,64}$/
+
+const wireConfidenceSchema = z.number().nullish()
+
+const wireChoiceAnswerSchema = z.object({
+  choice: z.string(),
+  confidence: wireConfidenceSchema,
+  probabilities: z.record(z.string(), z.number()),
+})
+
+const wireScoreAnswerSchema = z.object({
+  confidence: wireConfidenceSchema,
+  probabilities: z.union([z.array(z.number()), z.record(z.string(), z.number())]),
+})
+
+const wireNoulAnswerSchema = z.object({
+  noul: z.number(),
+})
+
+const wireResponseSchema = z.object({
+  model: z.string().nullish(),
+  answers: z.record(z.string(), z.unknown()),
+  usage: z.record(z.string(), z.unknown()).nullish(),
+})
+
+function readEnv(env: EnvLookup | undefined, key: string): string | undefined {
+  const value = (env ?? process.env)[key]
+  if (typeof value !== 'string') return undefined
+  const trimmed = value.trim()
+  return trimmed.length > 0 ? trimmed : undefined
+}
+
+function resolveBaseUrl(env: EnvLookup | undefined): string {
+  const configured = readEnv(env, BASE_URL_ENV) ?? DEFAULT_BASE_URL
+  return configured.replace(/\/+$/, '')
+}
+
+function serializeOrderedObject(entries: Array<[string, string]>): string {
+  return `{${entries.map(([key, serializedValue]) => `${JSON.stringify(key)}:${serializedValue}`).join(',')}}`
+}
+
+function serializeCriteria(question: DecisionQuestion): string {
+  switch (question.type) {
+    case 'choice':
+      return serializeOrderedObject(question.options.map((option) => [option.key, JSON.stringify(option.criteria)]))
+    case 'score':
+      return JSON.stringify(question.levels)
+    case 'binary':
+      return JSON.stringify({ true: question.criteria.true, false: question.criteria.false })
+  }
+}
+
+function wireQuestionType(question: DecisionQuestion): string {
+  return question.type === 'binary' ? 'noul' : question.type
+}
+
+function serializeQuestion(question: DecisionQuestion): string {
+  return serializeOrderedObject([
+    ['type', JSON.stringify(wireQuestionType(question))],
+    ['instructions', JSON.stringify(question.instructions)],
+    ['criteria', serializeCriteria(question)],
+  ])
+}
+
+function serializeRequestBody(request: DecisionRequest, modelId: string): string {
+  const entries: Array<[string, string]> = [
+    ['model', JSON.stringify(modelId)],
+    ['state', JSON.stringify(request.state) ?? 'null'],
+    ['questions', serializeOrderedObject(
+      Object.entries(request.questions).map(([questionName, question]) => [questionName, serializeQuestion(question)]),
+    )],
+  ]
+  if (request.sessionId !== undefined) {
+    entries.push(['session_id', JSON.stringify(request.sessionId)])
+  }
+  return serializeOrderedObject(entries)
+}
+
+function mapHttpStatus(status: number): DecisionErrorCode {
+  switch (status) {
+    case 400:
+    case 422:
+      return 'invalid_request'
+    case 401:
+    case 403:
+      return 'auth'
+    case 402:
+      return 'insufficient_credits'
+    case 404:
+      return 'unavailable'
+    case 413:
+      return 'payload_too_large'
+    case 429:
+      return 'rate_limited'
+    case 524:
+      return 'timeout'
+    default:
+      return 'provider_error'
+  }
+}
+
+function parseJson(text: string): unknown {
+  try {
+    return JSON.parse(text)
+  } catch {
+    return undefined
+  }
+}
+
+function extractVendorErrorCode(body: unknown): string | undefined {
+  if (!body || typeof body !== 'object') return undefined
+  const error = (body as { error?: unknown }).error
+  if (!error || typeof error !== 'object') return undefined
+  const code = (error as { code?: unknown }).code
+  const asString = typeof code === 'number' ? String(code) : code
+  return typeof asString === 'string' && VENDOR_ERROR_CODE_PATTERN.test(asString) ? asString : undefined
+}
+
+async function readErrorBodySafely(response: Response): Promise<unknown> {
+  try {
+    return parseJson(await response.text())
+  } catch {
+    return undefined
+  }
+}
+
+async function throwHttpError(response: Response): Promise<never> {
+  const vendorCode = extractVendorErrorCode(await readErrorBodySafely(response))
+  const suffix = vendorCode ? ` (vendor code ${vendorCode})` : ''
+  throw new DecisionModelError(
+    mapHttpStatus(response.status),
+    `OpenRouter decision request failed with HTTP ${response.status}${suffix}`,
+    response.status,
+  )
+}
+
+function unmappableAnswer(questionName: string): DecisionModelError {
+  return new DecisionModelError('invalid_response', `OpenRouter answer "${questionName}" has an unexpected shape`)
+}
+
+function mapChoiceAnswer(
+  questionName: string,
+  question: Extract<DecisionQuestion, { type: 'choice' }>,
+  wireAnswer: unknown,
+): RawDecisionAnswer {
+  const parsed = wireChoiceAnswerSchema.safeParse(wireAnswer)
+  if (!parsed.success) throw unmappableAnswer(questionName)
+  const wireProbabilities = new Map(Object.entries(parsed.data.probabilities))
+  const requestKeys = question.options.map((option) => option.key)
+  const requestKeySet = new Set(requestKeys)
+  const orderedKeys = [
+    ...requestKeys.filter((key) => wireProbabilities.has(key)),
+    ...[...wireProbabilities.keys()].filter((key) => !requestKeySet.has(key)),
+  ]
+  return {
+    type: 'choice',
+    value: parsed.data.choice,
+    probabilities: orderedKeys.map((key) => ({ key, probability: wireProbabilities.get(key) ?? 0 })),
+    confidence: parsed.data.confidence ?? null,
+  }
+}
+
+function mapScoreAnswer(questionName: string, wireAnswer: unknown): RawDecisionAnswer {
+  const parsed = wireScoreAnswerSchema.safeParse(wireAnswer)
+  if (!parsed.success) throw unmappableAnswer(questionName)
+  const wireProbabilities = parsed.data.probabilities
+  const probabilities = Array.isArray(wireProbabilities)
+    ? wireProbabilities.map((probability, level) => ({ level, probability }))
+    : Object.entries(wireProbabilities).map(([levelKey, probability]) => {
+      if (!/^\d+$/.test(levelKey)) throw unmappableAnswer(questionName)
+      return { level: Number(levelKey), probability }
+    })
+  return { type: 'score', probabilities, confidence: parsed.data.confidence ?? null }
+}
+
+function mapBinaryAnswer(questionName: string, wireAnswer: unknown): RawDecisionAnswer {
+  const parsed = wireNoulAnswerSchema.safeParse(wireAnswer)
+  if (!parsed.success) throw unmappableAnswer(questionName)
+  return { type: 'binary', probability: parsed.data.noul }
+}
+
+function mapWireAnswers(request: DecisionRequest, wireAnswers: Record<string, unknown>): Record<string, RawDecisionAnswer> {
+  const raw: Record<string, RawDecisionAnswer> = {}
+  for (const [questionName, question] of Object.entries(request.questions)) {
+    if (!Object.prototype.hasOwnProperty.call(wireAnswers, questionName)) continue
+    const wireAnswer = wireAnswers[questionName]
+    switch (question.type) {
+      case 'choice':
+        raw[questionName] = mapChoiceAnswer(questionName, question, wireAnswer)
+        break
+      case 'score':
+        raw[questionName] = mapScoreAnswer(questionName, wireAnswer)
+        break
+      case 'binary':
+        raw[questionName] = mapBinaryAnswer(questionName, wireAnswer)
+        break
+    }
+  }
+  return raw
+}
+
+function readUsageNumber(usage: Record<string, unknown> | null | undefined, key: string): number | null {
+  const value = usage?.[key]
+  return typeof value === 'number' && Number.isFinite(value) ? value : null
+}
+
+/**
+ * Decision model adapter for the OpenRouter Decisions API
+ * (`POST /api/alpha/decisions`). Maps the neutral port to the vendor wire
+ * shape and back; validation of the answers is delegated to
+ * `normalizeDecisionAnswers`.
+ */
+export function createOpenRouterDecisionAdapter(): DecisionModelAdapter {
+  return {
+    id: 'openrouter',
+    isConfigured: (env?: EnvLookup) => readEnv(env, API_KEY_ENV) !== undefined,
+    async decide(request: DecisionRequest, options): Promise<DecisionResult> {
+      const apiKey = readEnv(options.env, API_KEY_ENV)
+      if (!apiKey) {
+        throw new DecisionModelError('unavailable', 'OpenRouter decision adapter is not configured')
+      }
+      const startedAt = Date.now()
+      const response = await fetch(`${resolveBaseUrl(options.env)}/alpha/decisions`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${apiKey}`,
+        },
+        body: serializeRequestBody(request, options.modelId),
+        signal: options.signal,
+      })
+      if (!response.ok) {
+        await throwHttpError(response)
+      }
+      const parsed = wireResponseSchema.safeParse(parseJson(await response.text()))
+      if (!parsed.success) {
+        throw new DecisionModelError('provider_error', 'OpenRouter decision response body is not valid JSON of the expected shape')
+      }
+      const answers = normalizeDecisionAnswers(request, mapWireAnswers(request, parsed.data.answers))
+      return {
+        answers,
+        provider: 'openrouter',
+        model: parsed.data.model ?? options.modelId,
+        usage: {
+          inputTokens: readUsageNumber(parsed.data.usage, 'input_tokens'),
+          outputTokens: readUsageNumber(parsed.data.usage, 'output_tokens'),
+          costUsd: readUsageNumber(parsed.data.usage, 'cost'),
+        },
+        durationMs: Date.now() - startedAt,
+      }
+    },
+  }
+}