feat(Decision): use AI SDK experimental_decide

Replace hand-written fetch calls to OpenRouter/TypeSafe decision endpoints
with AI SDK experimental_decide via @openrouter/ai-sdk-provider and
@ai-sdk/typesafe-ai. Bumps ai to v7, which experimental_decide requires.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: DavertMik

lib/ai.js

@@ -3,7 +3,9 @@ const debug = debugModule('codeceptjs:ai')
 import output from './output.js'
 import event from './event.js'
 import { removeNonInteractiveElements, minifyHtml, splitByChunks } from './html.js'
-import { generateText } from 'ai'
+import { generateText, experimental_decide as decide, APICallError } from 'ai'
+import { createOpenRouter } from '@openrouter/ai-sdk-provider'
+import { createTypeSafeAi } from '@ai-sdk/typesafe-ai'
 import { fileURLToPath } from 'url'
 import path from 'path'
 import { fileExists, resolveImportModulePath } from './utils.js'
@@ -271,9 +273,9 @@ function parseCodeBlocks(response) {
   return modifiedSnippets.filter(snippet => !!snippet)
 }
 
-const DECISION_ENDPOINTS = {
-  openrouter: { url: 'https://openrouter.ai/api/alpha/decisions', keyName: 'OPENROUTER_API_KEY' },
-  typesafe: { url: 'https://api.typesafe.ai/v1/systemone', keyName: 'TYPESAFE_API_KEY' },
+const DECISION_PROVIDERS = {
+  openrouter: { keyName: 'OPENROUTER_API_KEY' },
+  typesafe: { keyName: 'TYPESAFE_API_KEY' },
 }
 
 const defaultDecisionConfig = {
@@ -292,20 +294,20 @@ class DecisionAI {
     this.config = { ...defaultDecisionConfig, ...config }
 
     const { provider, confidence } = this.config
-    this.endpoint = DECISION_ENDPOINTS[provider]
-    if (!this.endpoint) throw new Error(`Unknown decision provider "${provider}" in ai.decisionModel, use one of: ${Object.keys(DECISION_ENDPOINTS).join(', ')}`)
+    this.provider = DECISION_PROVIDERS[provider]
+    if (!this.provider) throw new Error(`Unknown decision provider "${provider}" in ai.decisionModel, use one of: ${Object.keys(DECISION_PROVIDERS).join(', ')}`)
     if (!(confidence > 0 && confidence < 1)) throw new Error(`ai.decisionModel.confidence must be between 0 and 1, got ${confidence}`)
 
     this.fetchImpl = fetch
   }
 
   checkModel() {
-    if (this.config.apiKey || process.env[this.endpoint.keyName]) return
+    if (this.config.apiKey || process.env[this.provider.keyName]) return
 
     const noKeyErrorMessage = `
      No API key is set for decision model.
 
-     [!] Set ${this.endpoint.keyName} environment variable or apiKey in ai.decisionModel config.
+     [!] Set ${this.provider.keyName} environment variable or apiKey in ai.decisionModel config.
 
      Example (connect to OpenRouter, default):
 
@@ -340,48 +342,48 @@ class DecisionAI {
   async decide(model, state, statements) {
     this.checkModel()
 
-    const apiKey = this.config.apiKey || process.env[this.endpoint.keyName]
-    const questions = Object.fromEntries(statements.map((statement, i) => [`q${i}`, { type: 'noul', instructions: statement }]))
+    const questions = Object.fromEntries(statements.map((statement, i) => [`q${i}`, { type: 'boolean', instructions: statement }]))
     debug('Decision request', model, statements)
 
     const controller = new AbortController()
     const timer = setTimeout(() => controller.abort(), this.config.timeout)
 
     let result
     try {
-      let response
-      try {
-        response = await this.fetchImpl(this.endpoint.url, {
-          method: 'POST',
-          headers: { Authorization: `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
-          body: JSON.stringify({ model, state, questions }),
-          signal: controller.signal,
-        })
-      } catch (err) {
-        throw new DecisionConnectionError(`Decision model ${model} request failed: ${err.message}`)
-      }
-
-      if (!response.ok) {
-        const body = await response.text().catch(() => '')
-        throw new Error(`Decision model ${model} responded with ${response.status}: ${body}`)
-      }
-
-      result = await response.json()
+      result = await decide({
+        model: this.decisionModel(model),
+        state,
+        questions,
+        maxRetries: 0,
+        abortSignal: controller.signal,
+      })
     } catch (err) {
       if (controller.signal.aborted) throw new DecisionConnectionError(`Decision model ${model} did not respond in ${this.config.timeout}ms`)
+      if (APICallError.isInstance(err)) throw new Error(`Decision model ${model} responded with ${err.statusCode}: ${err.responseBody || err.message}`)
       throw err
     } finally {
       clearTimeout(timer)
     }
 
-    debug('Decision response', result?.answers, result?.usage)
+    debug('Decision response', result.answers, result.usage)
 
-    const answers = result?.answers || {}
-    return statements.map((statement, i) => {
-      const probability = answers[`q${i}`]?.noul
-      if (typeof probability !== 'number') throw new Error(`Decision model ${model} returned no answer for "${statement}"`)
-      return probability
-    })
+    return Object.keys(questions).map(id => result.answers[id].probability)
+  }
+
+  decisionModel(model) {
+    const settings = {
+      apiKey: this.config.apiKey || process.env[this.provider.keyName],
+      fetch: async (url, options) => {
+        try {
+          return await this.fetchImpl(url, options)
+        } catch (err) {
+          if (options.signal?.aborted) throw err
+          throw new DecisionConnectionError(`Decision model ${model} request failed: ${err.message}`)
+        }
+      },
+    }
+    if (this.config.provider === 'typesafe') return createTypeSafeAi(settings).decisionModel(model)
+    return createOpenRouter(settings).evaluationModel(model)
   }
 }
 

package.json

@@ -93,15 +93,17 @@
     "publish-beta": "./runok.cjs publish:next-beta-version"
   },
   "dependencies": {
+    "@ai-sdk/typesafe-ai": "^3.0.15",
     "@codeceptjs/configure": "^4.0.0-beta.4",
     "@codeceptjs/helper": "2.0.4",
     "@cucumber/cucumber-expressions": "18",
     "@cucumber/gherkin": "38.0.0",
     "@cucumber/messages": "32.3.1",
     "@modelcontextprotocol/sdk": "^1.26.0",
+    "@openrouter/ai-sdk-provider": "^3.1.0",
     "@xmldom/xmldom": "0.9.10",
     "acorn": "8.15.0",
-    "ai": "^6.0.43",
+    "ai": "^7.0.131",
     "arrify": "3.0.0",
     "axios": "1.16.1",
     "chalk": "4.1.2",

test/unit/ai_test.js

@@ -325,7 +325,7 @@ describe('DecisionAI', () => {
     const decisionAI = new DecisionAI({ apiKey: 'secret' })
     decisionAI.fetchImpl = async (url, options) => {
       calls.push({ url, body: JSON.parse(options.body) })
-      return { ok: true, json: async () => ({ answers: { q0: { type: 'noul', noul: 0.9 }, q1: { type: 'noul', noul: 0.2 } } }) }
+      return Response.json({ answers: { q0: { type: 'noul', noul: 0.9 }, q1: { type: 'noul', noul: 0.2 } } })
     }
 
     const probabilities = await decisionAI.decide('typesafe/jev-1.13', { url: 'http://localhost' }, ['form is shown', 'cart is empty'])

test/unit/helper/Decision_test.js

@@ -13,13 +13,9 @@ function createDecision(decisionModel, config = {}) {
 
 function fakeFetch(answers, calls, status = 200) {
   return async (url, options) => {
-    calls.push({ url, body: JSON.parse(options.body), headers: options.headers })
-    return {
-      ok: status === 200,
-      status,
-      text: async () => 'boom',
-      json: async () => ({ answers }),
-    }
+    calls.push({ url, body: JSON.parse(options.body), headers: new Headers(options.headers) })
+    if (status !== 200) return new Response('boom', { status })
+    return Response.json({ answers })
   }
 }
 
@@ -53,7 +49,7 @@ describe('Decision helper', () => {
     expect(probability).to.equal(0.9)
     expect(calls).to.have.length(1)
     expect(calls[0].url).to.equal('https://openrouter.ai/api/alpha/decisions')
-    expect(calls[0].headers.Authorization).to.equal('Bearer secret')
+    expect(calls[0].headers.get('authorization')).to.equal('Bearer secret')
     expect(calls[0].body.model).to.equal('typesafe/jev-1.13')
     expect(calls[0].body.questions).to.eql({ q0: { type: 'noul', instructions: 'submit button is present' } })
     expect(calls[0].body.state.url).to.equal('http://localhost/checkout')
@@ -146,7 +142,7 @@ describe('Decision helper', () => {
   it('reports missing answers', async () => {
     decision.decisionAI.fetchImpl = fakeFetch({}, calls)
     const err = await decision.decide('page is loaded').catch(e => e)
-    expect(err.message).to.include('returned no answer for "page is loaded"')
+    expect(err.message).to.include('Decision must return exactly one answer for every question')
   })
 
   it('times out hanging requests', async () => {
@@ -162,11 +158,10 @@ describe('Decision helper', () => {
   it('times out stalled response body', async () => {
     decision = createDecision({ apiKey: 'secret', timeout: 50 })
     decision._actingHelper = () => browser
-    decision.decisionAI.fetchImpl = async (url, { signal }) => ({
-      ok: true,
-      status: 200,
-      json: () => new Promise((_, reject) => signal.addEventListener('abort', () => reject(new Error('aborted')))),
-    })
+    decision.decisionAI.fetchImpl = async (url, { signal }) => {
+      const body = new ReadableStream({ start: controller => signal.addEventListener('abort', () => controller.error(new Error('aborted'))) })
+      return new Response(body, { headers: { 'content-type': 'application/json' } })
+    }
 
     const err = await decision.decide('page is loaded').catch(e => e)
     expect(err.message).to.include('did not respond in 50ms')