@browserless/ai 13.9.3

package/src/run-ai.js

@@ -0,0 +1,151 @@
+'use strict'
+
+const runAi = async spec => {
+  const parseJson = raw => {
+    try {
+      return JSON.parse(raw)
+    } catch (error) {
+      const start = String(raw).indexOf('{')
+      const end = String(raw).lastIndexOf('}')
+      if (start !== -1 && end > start) {
+        try {
+          return JSON.parse(raw.slice(start, end + 1))
+        } catch {}
+      }
+      const preview = String(raw).replace(/\s+/g, ' ').slice(0, 160)
+      throw new Error(`LanguageModel did not return JSON: ${preview}`, { cause: error })
+    }
+  }
+
+  const names = {
+    prompt: 'LanguageModel',
+    summarize: 'Summarizer',
+    translate: 'Translator',
+    detectLanguage: 'LanguageDetector'
+  }
+
+  if (spec.api === 'availability') {
+    const probes = {
+      languageModel: {
+        name: 'LanguageModel',
+        opts: {
+          expectedInputs: [{ type: 'text', languages: ['en'] }],
+          expectedOutputs: [{ type: 'text', languages: ['en'] }]
+        }
+      },
+      summarizer: {
+        name: 'Summarizer',
+        opts: { expectedInputLanguages: ['en'], outputLanguage: 'en' }
+      },
+      translator: {
+        name: 'Translator',
+        opts: { sourceLanguage: 'en', targetLanguage: 'es' }
+      },
+      languageDetector: {
+        name: 'LanguageDetector',
+        opts: { expectedInputLanguages: ['en'] }
+      }
+    }
+    const apis = {}
+    const ctors = {}
+    for (const [api, { name, opts }] of Object.entries(probes)) {
+      const Ctor = globalThis[name]
+      ctors[api] = typeof Ctor
+      if (typeof Ctor === 'undefined') {
+        apis[api] = 'unavailable'
+        continue
+      }
+      try {
+        apis[api] = await Ctor.availability(opts)
+      } catch {
+        apis[api] = 'unavailable'
+      }
+    }
+    return {
+      apis,
+      env: {
+        hardwareConcurrency: globalThis.navigator && globalThis.navigator.hardwareConcurrency,
+        deviceMemory: globalThis.navigator && globalThis.navigator.deviceMemory,
+        ...Object.fromEntries(Object.entries(ctors).map(([key, value]) => [`ctor_${key}`, value]))
+      }
+    }
+  }
+
+  const schema = spec.schema || spec.responseConstraint
+  const name = schema && spec.api === 'summarize' ? 'LanguageModel' : names[spec.api]
+  const Ctor = globalThis[name]
+  if (typeof Ctor === 'undefined') throw new Error(`${name} is not available`)
+
+  const createKeys = {
+    prompt: ['initialPrompts', 'expectedInputs', 'expectedOutputs', 'temperature', 'topK'],
+    summarize: [
+      'type',
+      'format',
+      'length',
+      'sharedContext',
+      'expectedInputLanguages',
+      'outputLanguage',
+      'expectedContextLanguages'
+    ],
+    translate: ['sourceLanguage', 'targetLanguage'],
+    detectLanguage: ['expectedInputLanguages']
+  }
+
+  const keys =
+    name === 'LanguageModel' ? createKeys.prompt : createKeys[spec.api] || createKeys.prompt
+  const createOpts = {}
+  for (const key of keys) {
+    if (spec[key] !== undefined) createOpts[key] = spec[key]
+  }
+
+  if (spec.api === 'translate' && (!createOpts.sourceLanguage || !createOpts.targetLanguage)) {
+    throw new Error('Translator requires sourceLanguage and targetLanguage')
+  }
+
+  let availability = await Ctor.availability(createOpts)
+  if (availability === 'unavailable') throw new Error(`${name} is unavailable`)
+
+  if (availability === 'downloading') {
+    const started = Date.now()
+    while (availability === 'downloading' && Date.now() - started < 240000) {
+      await new Promise(resolve => setTimeout(resolve, 1000))
+      availability = await Ctor.availability(createOpts)
+    }
+    if (availability === 'unavailable' || availability === 'downloading') {
+      throw new Error(`${name} is ${availability}`)
+    }
+  }
+
+  const instance = await Ctor.create({
+    ...createOpts,
+    monitor (m) {
+      m.addEventListener('downloadprogress', e => {
+        console.log(`download ${name} ${Math.round(e.loaded * 100)}%`)
+      })
+    }
+  })
+  try {
+    const pageText =
+      (globalThis.document && globalThis.document.body && globalThis.document.body.innerText) || ''
+    const input = spec.text !== undefined ? spec.text : pageText
+    if (spec.api === 'prompt' || (schema && name === 'LanguageModel')) {
+      let prompt = input
+      if (spec.prompt) prompt = input ? `${spec.prompt}\n\n${input}` : spec.prompt
+      else if (schema) prompt = `Extract metadata from this page.\n\n${input}`
+      const result = await instance.prompt(
+        prompt,
+        schema ? { responseConstraint: schema } : undefined
+      )
+      return schema ? parseJson(result) : result
+    }
+    if (spec.api === 'summarize') {
+      return await instance.summarize(input, spec.context ? { context: spec.context } : undefined)
+    }
+    if (spec.api === 'translate') return await instance.translate(input)
+    return await instance.detect(input)
+  } finally {
+    if (typeof instance.destroy === 'function') instance.destroy()
+  }
+}
+
+module.exports = runAi

package/src/unpack.js

@@ -0,0 +1,145 @@
+'use strict'
+
+const { pipeline } = require('node:stream/promises')
+const { createInflateRaw } = require('node:zlib')
+const { open } = require('node:fs/promises')
+const { Readable } = require('node:stream')
+const path = require('node:path')
+
+const {
+  createReadStream,
+  createWriteStream,
+  existsSync,
+  mkdirSync,
+  renameSync,
+  rmSync,
+  unlinkSync,
+  writeFileSync
+} = require('node:fs')
+
+const debug = require('debug-logfmt')('browserless:ai')
+const { hasFile, cacheRoot } = require('./find-dir')
+
+const installed = dir => {
+  if (!hasFile(dir, 'weights.bin')) return
+  const hasAdaptation =
+    ['prompt', 'summarize', 'detect'].some(name =>
+      hasFile(path.join(dir, name), 'model-info.pb')
+    ) || hasFile(dir, 'model-info.pb')
+  if (!hasAdaptation) return
+  return { dir }
+}
+
+const writeZip = async (input, dest) => {
+  if (input == null) {
+    if (!existsSync(dest)) throw new Error('download did not write a zip')
+    return dest
+  }
+  if (typeof input === 'string') return path.resolve(input)
+  mkdirSync(path.dirname(dest), { recursive: true })
+  if (Buffer.isBuffer(input) || input instanceof Uint8Array) {
+    writeFileSync(dest, input)
+    return dest
+  }
+  const body = input.body || input.Body || input
+  const stream = typeof body.getReader === 'function' ? Readable.fromWeb(body) : body
+  await pipeline(stream, createWriteStream(dest))
+  return dest
+}
+
+const safeDest = (dir, name) => {
+  if (name.endsWith('/')) return
+  const dest = path.join(dir, name)
+  const rel = path.relative(dir, dest)
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) {
+    throw new Error(`refusing to extract ${name}`)
+  }
+  return dest
+}
+
+const unzipJs = async (zipPath, dir) => {
+  const fd = await open(zipPath, 'r')
+  try {
+    let pos = 0
+    const read = async (length, at = pos) => {
+      const buf = Buffer.alloc(length)
+      const { bytesRead } = await fd.read(buf, 0, length, at)
+      return buf.subarray(0, bytesRead)
+    }
+
+    while (true) {
+      const sig = await read(4, pos)
+      if (sig.length < 4 || sig.readUInt32LE(0) !== 0x04034b50) break
+      const rest = await read(26, pos + 4)
+      const flags = rest.readUInt16LE(2)
+      const method = rest.readUInt16LE(4)
+      const compressed = rest.readUInt32LE(14)
+      const nameLen = rest.readUInt16LE(22)
+      const extraLen = rest.readUInt16LE(24)
+      const name = (await read(nameLen, pos + 30)).toString()
+      if (flags & 0x08) {
+        throw new Error(`unsupported zip entry with data descriptor (${name})`)
+      }
+      const dataStart = pos + 30 + nameLen + extraLen
+      const dest = safeDest(dir, name)
+      pos = dataStart + compressed
+      if (!dest) continue
+      if (method !== 0 && method !== 8) {
+        throw new Error(`unsupported zip method ${method} (${name})`)
+      }
+      mkdirSync(path.dirname(dest), { recursive: true })
+      process.stderr.write(`extracting ${name}\n`)
+      if (compressed === 0) {
+        writeFileSync(dest, '')
+        continue
+      }
+      const source = createReadStream(zipPath, {
+        start: dataStart,
+        end: dataStart + compressed - 1
+      })
+      const destStream = createWriteStream(dest)
+      if (method === 8) await pipeline(source, createInflateRaw(), destStream)
+      else await pipeline(source, destStream)
+    }
+  } finally {
+    await fd.close()
+  }
+}
+
+const unzip = async (zipPath, dir) => {
+  mkdirSync(dir, { recursive: true })
+  await unzipJs(zipPath, dir)
+}
+
+const unpack = async (get, { dir, force = false } = {}) => {
+  if (get == null) throw new Error('unpack requires a zip path or download function')
+  dir = path.resolve(dir || process.env.BROWSERLESS_AI_DIR || cacheRoot())
+  mkdirSync(dir, { recursive: true })
+
+  const already = installed(dir)
+  debug('unpack', { dir, force, installed: Boolean(already) })
+  if (already && !force) return already
+
+  const staging = `${dir}.partial`
+  rmSync(staging, { recursive: true, force: true })
+  mkdirSync(staging, { recursive: true })
+  try {
+    const dest = path.join(staging, 'bundle.zip')
+    const zipPath =
+      typeof get === 'function' ? await writeZip(await get(dest), dest) : path.resolve(get)
+    if (!existsSync(zipPath)) throw new Error(`missing zip: ${zipPath}`)
+
+    await unzip(zipPath, staging)
+    if (zipPath === dest) unlinkSync(dest)
+    const paths = installed(staging)
+    if (!paths) throw new Error('bundle did not contain nano weights and an adaptation')
+    rmSync(dir, { recursive: true, force: true })
+    renameSync(staging, dir)
+    return { dir }
+  } catch (error) {
+    rmSync(staging, { recursive: true, force: true })
+    throw error
+  }
+}
+
+module.exports = unpack