alexa-ai 2.1.1 → 2.2.1

package/CHANGELOG.md

@@ -4,6 +4,80 @@ All notable changes to `alexa-ai` are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and the project uses
 [Semantic Versioning](https://semver.org/).
 
+## [2.2.1] — 2026-09-07
+
+### Added
+- Device identity: the client keeps a stable random `deepai_device_id`
+  (32 bytes, base64url) and sends it as a cookie; anonymous `/api/*`
+  generation is rate-limited per device. Override with `deviceId` /
+  `DEEPAI_DEVICE_ID`.
+- `examples/text2img-standalone.js` — zero-dependency CLI for anonymous
+  image generation using the full browser request dialect.
+
+## [2.2.0] — 2026-09-07
+
+### Fixed
+- Image generation with anonymous `tryit-…` keys. The key's hex part is a
+  deterministic hash over the User-Agent
+  (`H(UA + H(UA + H(UA + digits + SALT)))`, see `DeepAIClient._islandHash`);
+  `generateTryItKey(userAgent)` now derives it correctly, and `headers()`
+  mints a fresh key per request because anonymous keys are single-use.
+- `generateImage()` now sends the browser dialect for anonymous requests
+  (`generation_source`, `width`/`height` mapped from `aspectRatio`,
+  `image_generator_version`, `quality`).
+
+### Added
+- Anonymous browser-shaped retry when a registered non-Pro key is refused
+  (result `via: 'anonymous'`, `runApiWithTryItKey(name, fields)`); disable
+  with `{ noAnonymousFallback: true }`.
+- `DEEPAI_KEY` env alias alongside `DEEPAI_API_KEY`.
+- `DeepAIClient.isTryItKey(key)`.
+
+### Changed
+- Extended refusal classification ("Pro members", "model only available…",
+  "insufficient_credits", …) so quota errors rotate keys and report
+  `DEEPAI_QUOTA_EXCEEDED` correctly.
+- `share_url` preferred over `output_url` in generated-image results.
+- Default `userAgent` updated (the tryit key hash is computed over it; keep
+  `userAgent` stable if you persist keys).
+
+## [2.1.2] — 2026-09-06
+
+### Changed
+- **`searchWeb()` now searches the web itself** instead of trusting DeepAI's
+  server-side web access. Observed live with `gpt-4o-mini`: the same query
+  produced one report without any sources and one with four invented links,
+  because the model skipped the search and wrote from memory. The engine now
+  queries Bing, Bing News, Wikipedia, Google News and DuckDuckGo in parallel
+  (no API key needed; the four feeds were verified live on 2026-09-06 —
+  DuckDuckGo's html endpoint serves a bot challenge from data-centre IPs, so
+  its lite endpoint is tried first and a challenge page yields no results), hands the results to the model as numbered material, and asks
+  it to cite result numbers and never write URLs. The `*Sources:*` block is
+  built from the search results only — cited first — so a link the model made
+  up can never reach the chat. Citation markers are removed from the prose;
+  URLs the model still types are turned into citations when they match a
+  result and dropped otherwise.
+- Result gained `grounded` (did the engine's search answer?), `providers`,
+  `via` (`'model'` | `'digest'`), and each source carries `date`, `provider`
+  and `cited`.
+- New options: `results` (bring your own search API's results), `search:false`,
+  `providers`, `maxResults`; constructor options `webSearch`,
+  `webSearchProviders`, `webSearchTimeout`, `webSearchResults`,
+  `webSearchProvider(query, { maxResults, signal })`.
+- When every provider fails the request falls back to DeepAI's web access as
+  before (`grounded:false`); when the search worked but the model call failed,
+  a plain digest of the results is returned (`via:'digest'`, still `ok:true`).
+
+### Added
+- `WebSearch` service (exported) with parsers for the DuckDuckGo html/lite
+  pages, RSS 2.0 news feeds and the MediaWiki search API, redirect unwrapping
+  (`duckduckgo.com/l/?uddg=`, `bing.com/news/apiclick.aspx?url=`), ad and
+  duplicate filtering, and provider round-robin.
+- `WebAnswer.formatResults()`, `extractCitations()`, `stripUrls()`, `digest()`.
+- The npm package now ships the test suite (`test/`), so the published
+  tarball is a complete snapshot of the repository at the tagged version:
+  `npm explore alexa-ai -- npm test`.
+
 ## [2.1.1] — 2026-09-06
 
 ### Fixed

package/README.md

@@ -427,23 +427,39 @@ await ai.deepai.runApi('waifu2x', { image: buffer });       // any /api/<name> e
 
 All media arguments accept the same shapes as `chat({ image })`.
 
-**`generateImage()` on a free key.** `POST /api/text2img` is a paid endpoint:
-anonymous keys receive `{"status": "Out of API credits"}`. The engine tries it
-first because it is fast and returns a plain URL; when it is refused, it
-drives the same in-chat `generate_image` tool the deepai.org web client uses,
-which works on free chat keys. The result reports the route that answered
-(`via: 'api' | 'chat'`). Options: `{ apiOnly }`, `{ chatToolOnly }`,
-`{ aspectRatio: '16:9' }` for the chat tool, and `width` / `height` /
-`image_generator_version` for the API.
+**`generateImage()` on a free key.** Three routes are tried, in order:
+
+1. `POST /api/text2img` with your key. Pro keys succeed here immediately.
+   With an anonymous `tryit-…` key the engine automatically sends the exact
+   browser dialect (`generation_source=chat`, `width`/`height` mapped from
+   `aspectRatio`, `image_generator_version=hd`, `quality=true`) and mints a
+   **fresh single-use key per request** — tryit keys are hash-validated
+   against the User-Agent and burned after one request.
+2. If a registered (non-Pro) key is refused with `402 "Pro members in good
+   standing"`, one anonymous browser-shaped retry. (`noAnonymousFallback:
+   true` disables it.)
+3. The legacy in-chat `generate_image` function call (kept for model
+   versions that still honour it).
+
+The result reports the route that answered (`via: 'api' | 'anonymous' |
+'chat'`). Options: `{ apiOnly }`, `{ chatToolOnly }`, `{ noAnonymousFallback }`,
+`{ aspectRatio: '16:9' }`, and `width` / `height` / `image_generator_version`
+for the API. The returned URL prefers `share_url` (public, stable) over
+`output_url`, matching the browser client.
 
 **`summarizeText()`** follows the same pattern — `/api/summarization` first, a
 stateless chat request as the fallback.
 
-**`searchWeb()`** is a one-off research request with DeepAI's web access
-enabled. It applies the persona and formatting rules but touches no user's
-memory or history, so it can be called with no jid at all. The default answer
-is long-form and ready to send to WhatsApp — an intro, three to five
-`*Heading:*` sections with numbered `*Title*: detail` points, and one
+**`searchWeb()`** is a one-off research request that touches no user's
+memory or history, so it can be called with no jid at all. The engine does the
+searching itself — Bing, Bing News, Wikipedia, Google News and DuckDuckGo, in
+parallel, no API key needed — and hands the results to the model as numbered
+material. The model writes the report from them and cites result numbers; it
+is told never to write a URL. The `*Sources:*` block is then built from the
+search results only (cited ones first), so every link the bot shows is a page
+that actually came back from a search, never one the model made up. The
+default answer is long-form and ready to send to WhatsApp — an intro, three to
+five `*Heading:*` sections with numbered `*Title*: detail` points, and one
 `*Sources:*` block at the end:
 
 ```
@@ -471,15 +487,25 @@ answer still comes back under `minWords` (default 150), one follow-up turn asks
 the model to rewrite it in full, and the longer reply wins — `attempts` and
 `words` in the result show what happened.
 
-DeepAI reports the pages it used in two different ways depending on the model
-that answered: some send a structured web-results packet, others (observed
-with `gpt-4o-mini`) just write a `Sources:` list in prose. Both end up in the
-`sources` array as `{ title, url, description }`; the list is rendered exactly
-once in `text`, and `answer` holds the prose without it. Sentences in which
-the model talks about itself — *"I'm a language model"*, *"I can't browse the
-web"*, *"based on my training data"* — are removed, and leftover template
-placeholders are dropped. Third-party names in the research itself (news
-about OpenAI or Google) are kept verbatim.
+The result tells you which path answered:
+
+```js
+const r = await ai.searchWeb('coffee');
+// r.grounded   true  → the engine searched; sources are real search results
+//              false → no search results (host offline / providers blocked);
+//                      DeepAI's own web access answered, and its sources are
+//                      whatever the model reported — treat them with care
+// r.providers  ['bing', 'bing-news', 'wikipedia', 'google-news', 'duckduckgo'] — who answered
+// r.sources    [{ title, url, description, date, provider, cited }]
+// r.via        'model' | 'digest' (the model failed but the search worked:
+//                                  a plain list of the results is returned)
+// r.words, r.attempts, r.model
+```
+
+Sentences in which the model talks about itself — *"I'm a language model"*,
+*"I can't browse the web"*, *"based on my training data"* — are removed, and
+leftover template placeholders are dropped. Third-party names in the research
+itself (news about OpenAI or Google) are kept verbatim.
 
 ```js
 await ai.searchWeb('coffee', {
@@ -489,9 +515,37 @@ await ai.searchWeb('coffee', {
     maxSources: 3,            // how many to list in `text` (the array is not capped)
     language: 'Sinhala',      // answer language (default: the language of the query)
     instructions: 'focus on Sri Lanka',
+    providers: ['bing-news', 'google-news'],   // only news for this call
+    maxResults: 5,            // results handed to the model (default 8)
+    search: false,            // skip the built-in search, use DeepAI's web access
+});
+
+// Bring your own search API (Brave, Serper, Tavily, …): pass its results and
+// the built-in search is skipped — the sources block is built from them.
+await ai.searchWeb('coffee', {
+    results: [{ title, url, description, date }],
 });
 ```
 
+Engine-wide settings in the constructor:
+
+```js
+new AlexaAI({
+    webSearch: true,                       // false = never search; always use DeepAI's
+    webSearchProviders: ['bing', 'bing-news', 'wikipedia', 'google-news', 'duckduckgo'],
+    webSearchTimeout: 8000,                // per provider, ms
+    webSearchResults: 8,                   // results handed to the model
+    webSearchProvider: async (query, { maxResults, signal }) => [...],  // replace the built-ins
+});
+```
+
+The built-in providers are public pages and feeds, so they can change or be
+rate-limited; each one is best-effort and a failure just means fewer results.
+When none return anything the request falls back to DeepAI's server-side web
+access — which on the free models is exactly the behaviour that motivated this
+design: it often skips the search and writes a plausible report with invented
+links. Check `grounded` if that matters to you.
+
 ### Moderation and administration
 
 ```js
@@ -601,7 +655,8 @@ AlexaAI                     orchestrator; the only class the bot touches
 │                           no "Alexa Mini", no self-denial)
 ├── AmnesiaGuard            never lets her deny a memory she actually has
 ├── ImageDescriber          vision chain: documents -> DeepAI -> OCR -> fallback
-├── WebAnswer               searchWeb prompt; lifts "Sources:" lists out of prose
+├── WebSearch               the engine's own web search (Bing, Bing/Google News, Wikipedia, DuckDuckGo)
+├── WebAnswer               searchWeb prompt, citation handling, sources block
 ├── Media                   normalises every media input shape
 └── JidParser               normalises @lid / @s.whatsapp.net / @g.us
 ```
@@ -770,7 +825,7 @@ refresh it automatically. Reinstall and verify:
 ```bash
 npm uninstall alexa-ai
 npm install github:AlexaInc/deepai
-node -e "console.log(require('alexa-ai').version)"   # must print 2.1.1 or newer
+node -e "console.log(require('alexa-ai').version)"   # must print 2.1.2 or newer
 ```
 
 `AlexaAI.version` and `AlexaAI.methods()` let the bot assert this at startup;
@@ -780,15 +835,53 @@ node -e "console.log(require('alexa-ai').version)"   # must print 2.1.1 or newer
 `text`**
 Fixed in 2.1.1. Earlier builds asked the model for *"a short, direct answer"*
 and only read sources from DeepAI's structured packet, which `gpt-4o-mini`
-does not send. Reinstall as above and confirm the version is 2.1.1 or newer.
-If a particular model still answers briefly, check `attempts` / `words` in the
-result: the engine retries once below `minWords`, and a persistently short
-model is best swapped with the `model` option.
+does not send. If a particular model still answers briefly, check `attempts` /
+`words` in the result: the engine retries once below `minWords`, and a
+persistently short model is best swapped with the `model` option.
+
+**`searchWeb()` sometimes has no sources, or the sources are links that do
+not exist**
+Fixed in 2.1.2. Before, the model was both researcher and writer: DeepAI's
+server-side search ran unreliably on the free models, so the model often
+wrote from memory — one run had no sources, the next had four invented ones.
+The engine now searches the web itself and the sources block is built only
+from those results. If `sources` is still empty, look at `grounded` in the
+result: `false` means none of the search providers answered from your host
+(firewall, DNS, rate limit — enable `debug:true` to see each provider's
+error), and the reply came from DeepAI's own web access. Point
+`webSearchProvider` at a search API you control if the public endpoints are
+blocked where the bot runs.
+
+**Works in the browser playground but fails in Postman / Node.js** — three
+separate requirements:
+
+1. **Anonymous keys are single-use and User-Agent-bound.** Each key is
+   `tryit-<digits>-<hash>` with
+   `hash = H(UA + H(UA + H(UA + digits + "hackers_become_a_little_stinkier_every_time_they_hack")))`,
+   validated against the request's `User-Agent` header. A reused key or
+   random hex → `401 "Please pass a valid Api-Key"`. A fresh, correctly
+   hashed key must be minted per request — `headers()` does this
+   automatically for `tryit-…` keys.
+2. **The body must be `multipart/form-data`** (never JSON), with
+   `generation_source=img` (model page) or `generation_source=chat` +
+   `width`/`height`/`image_generator_version=hd`/`quality=true` (chat page).
+   Never set `Content-Type` manually — the multipart boundary is generated.
+3. **`Origin: https://deepai.org` is required**, and anonymous generation is
+   refused from datacenter/VPN IPs (`401 "Please try this model on deepai.org"`) —
+   run from a residential IP. Passing `deviceId` (the `deepai_device_id`
+   cookie value) also helps the per-device quota.
+
+`examples/text2img-standalone.js` is a zero-dependency CLI implementing the
+full recipe.
 
 **`generateImage()` returns `{ ok: false, error: 'DEEPAI_QUOTA_EXCEEDED' }`**
-Both routes were refused: `/api/text2img` needs credits and the in-chat image
-tool hit the key's chat quota. Add more keys (`keys: [...]`) or wait for the
-quota to reset. `message` carries DeepAI's exact wording.
+`/api/text2img` is Pro-only for registered keys ("APIs are only available for
+Pro members in good standing"), the anonymous browser-shaped retry was
+refused too (DeepAI soft-blocks free image generation from datacenter IPs
+with "Please try this model on deepai.org" — run the bot from a residential
+IP), and the in-chat tool produced no image. Add a Pro key, more keys
+(`keys: [...]`), or run from a non-datacenter IP. `message` carries DeepAI's
+exact wording for each attempted route.
 
 **Photos are answered with "I can't view images right now"**
 Native vision needs a paid DeepAI key; on a free key only text inside the

package/examples/text2img-standalone.js

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+'use strict';
+/**
+ * text2img-standalone.js — zero-dependency DeepAI text-to-image CLI.
+ *
+ * Speaks the anonymous browser dialect: a fresh single-use `tryit-…` key
+ * (hashed over the User-Agent) per run, browser-identical headers and a
+ * multipart/form-data body, plus a stable `deepai_device_id` cookie.
+ *
+ * Usage:
+ *   node examples/text2img-standalone.js "a cute orange cat"
+ *   node examples/text2img-standalone.js "a cat" --out cat.jpg
+ *   node examples/text2img-standalone.js "a cat" --aspect 16:9
+ *   node examples/text2img-standalone.js "a cat" --device-id <cookieValue>
+ *   node examples/text2img-standalone.js "a cat" --key <proKey>
+ *
+ * Requires Node.js 18+ (global fetch). Anonymous generation is refused
+ * from datacenter/VPN IPs; run from a residential network.
+ */
+
+const API_URL = 'https://api.deepai.org/api/text2img';
+const SALT = 'hackers_become_a_little_stinkier_every_time_they_hack';
+// Keep this EXACT string in sync with the User-Agent header below — the key
+// hash is computed over it and the server recomputes it from the request.
+const USER_AGENT =
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Safari/537.36';
+
+// ---------------------------------------------------------------------------
+// Deterministic key hash (see DeepAIClient._islandHash in the engine).
+// The integer/bit-level behaviour is intentional — do not simplify it.
+// ---------------------------------------------------------------------------
+function islandHash(input) {
+    const a = [];
+    for (let b = 0; 64 > b; ) a[b] = 0 | (4294967296 * Math.sin(++b % Math.PI));
+    let d, e, f, g = [(d = 1732584193), (e = 4023233417), ~d, ~e], h = [];
+    const l = unescape(encodeURI(input)) + '€';
+    let k = l.length;
+    let c = (--k / 4 + 2) | 15;
+    for (h[--c] = 8 * k; ~k; ) h[k >> 2] |= l.charCodeAt(k) << (8 * k--);
+    for (let b = 0, m = 0; b < c; b += 16) {
+        for (k = g; 64 > m; k = [ (f = k[3]), d + (((f = k[0] + [d & e | ~d & f, f & d | ~f & e, d ^ e ^ f, e ^ (d | ~f)][(k = m >> 4)] + a[m] + ~~h[b | [m, 5 * m + 1, 3 * m + 5, 7 * m][k] & 15]) << (k = [7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21][4 * k + (m++ % 4)])) | (f >>> -k)), d, e ]) {
+            d = k[1] | 0;
+            e = k[2];
+        }
+        for (m = 4; m; ) g[--m] += k[m];
+    }
+    let result = '';
+    for (let i = 0; 32 > i; ) result += ((g[i >> 3] >> 4 * (1 ^ i++)) & 15).toString(16);
+    return result.split('').reverse().join('');
+}
+
+/** Mint a fresh anonymous key, valid for exactly ONE request with USER_AGENT. */
+function freshTryItKey(userAgent = USER_AGENT) {
+    const digits = String(Math.round(Math.random() * 100000000000));
+    const H = islandHash;
+    return `tryit-${digits}-${H(userAgent + H(userAgent + H(userAgent + digits + SALT)))}`;
+}
+
+/** Random device id, same shape the site sets as the deepai_device_id cookie. */
+function randomDeviceId() {
+    return Buffer.from(crypto.getRandomValues(new Uint8Array(32))).toString('base64url');
+}
+
+// ---------------------------------------------------------------------------
+// CLI
+// ---------------------------------------------------------------------------
+function parseArgs(argv) {
+    const opts = { prompt: '', out: null, key: null, deviceId: randomDeviceId(), aspect: null, genSource: 'img' };
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '--out') opts.out = argv[++i];
+        else if (a === '--key') opts.key = argv[++i];
+        else if (a === '--device-id') opts.deviceId = argv[++i];
+        else if (a === '--aspect') opts.aspect = argv[++i];
+        else if (a === '--chat-source') opts.genSource = 'chat';
+        else if (a === '--help' || a === '-h') opts.help = true;
+        else if (!opts.prompt) opts.prompt = a;
+    }
+    return opts;
+}
+
+const ASPECTS = { '16:9': [832, 448], '4:3': [768, 576], '1:1': [640, 640], '3:4': [576, 768], '9:16': [448, 832] };
+
+async function main() {
+    const opts = parseArgs(process.argv.slice(2));
+    if (opts.help || !opts.prompt) {
+        console.log('Usage: node examples/text2img-standalone.js "your prompt" [--out file.jpg] [--key PRO_KEY] [--device-id VALUE] [--aspect 16:9|1:1|9:16|4:3|3:4] [--chat-source]');
+        process.exit(opts.help ? 0 : 1);
+    }
+
+    // ---- body: multipart/form-data, NEVER JSON -----------------------------
+    const form = new FormData();
+    form.append('text', opts.prompt);
+    form.append('generation_source', opts.genSource); // 'img' = model page, 'chat' = chat page
+    if (opts.aspect && ASPECTS[opts.aspect]) {
+        // the chat-page dialect maps aspect ratios to pixel sizes
+        const [w, h] = ASPECTS[opts.aspect];
+        form.append('width', String(w));
+        form.append('height', String(h));
+        form.append('image_generator_version', 'hd');
+        form.append('quality', 'true');
+    }
+
+    // ---- headers: fresh single-use anonymous key (or your Pro key) ---------
+    const apiKey = opts.key || freshTryItKey();
+    const headers = {
+        'api-key': apiKey,
+        'User-Agent': USER_AGENT, // MUST match the UA the key was hashed with
+        Origin: 'https://deepai.org',
+        Referer: 'https://deepai.org/machine-learning-model/text2img',
+        Accept: '*/*',
+        'Accept-Language': 'en-US,en;q=0.9',
+        Cookie: `deepai_device_id=${opts.deviceId}`,
+        // NOTE: do NOT set Content-Type yourself — undici adds the multipart
+        // boundary. A manual Content-Type without the boundary is rejected.
+    };
+
+    console.log(`Prompt : ${opts.prompt}`);
+    console.log(`Key    : ${opts.key ? '(registered key — needs Pro)' : apiKey + '  (fresh, single-use)'}`);
+    console.log('POST   : ' + API_URL);
+
+    const res = await fetch(API_URL, { method: 'POST', headers, body: form });
+    const raw = await res.text();
+    let data = null;
+    try { data = JSON.parse(raw); } catch { /* non-JSON */ }
+
+    if (!res.ok || data?.err || (data?.status && !data.share_url && !data.output_url)) {
+        console.error(`\nFAILED  HTTP ${res.status}`);
+        console.error(raw.slice(0, 500));
+        const s = String(data?.status || data?.err || '');
+        if (/valid Api-Key/i.test(s)) console.error('\n→ The key is invalid or already used. Keys are single-use and must be hashed for the exact User-Agent sent; this script mints a fresh one each run.');
+        else if (/try this model on deepai\.org/i.test(s)) console.error('\n→ DeepAI is refusing anonymous generation from your IP (datacenter/VPN) or the Origin header is missing. Run from a residential IP and keep the Origin/Referer headers.');
+        else if (/Pro members/i.test(s)) console.error('\n→ Your registered key is on the free plan; /api/* needs Pro. Use the anonymous mode (omit --key) or upgrade.');
+        else if (/try it exceeded/i.test(s)) console.error('\n→ Free quota for this device/IP is exhausted. Try a different --device-id or wait for the reset.');
+        process.exit(1);
+    }
+
+    const url = data.share_url || data.output_url;
+    console.log(`\nOK     HTTP ${res.status}`);
+    console.log(`Image  : ${url}`);
+    if (data.id) console.log(`ID     : ${data.id}`);
+
+    // ---- optional: download the image --------------------------------------
+    const out = opts.out || `deepai-${Date.now()}.jpg`;
+    try {
+        const img = await fetch(url);
+        if (img.ok) {
+            const buf = Buffer.from(await img.arrayBuffer());
+            require('fs').writeFileSync(out, buf);
+            console.log(`Saved  : ${out} (${(buf.length / 1024).toFixed(1)} KB)`);
+        } else {
+            console.log(`(download skipped: HTTP ${img.status} — open the URL above in a browser)`);
+        }
+    } catch (e) {
+        console.log(`(download failed: ${e.message} — open the URL above in a browser)`);
+    }
+}
+
+main().catch((e) => { console.error('ERROR:', e.message); process.exit(1); });

package/index.js

@@ -33,6 +33,7 @@ const ResponseFormatter = require('./src/services/ResponseFormatter');
 const TriggerDetector = require('./src/services/TriggerDetector');
 const ImageDescriber = require('./src/services/ImageDescriber');
 const WebAnswer = require('./src/services/WebAnswer');
+const WebSearch = require('./src/services/WebSearch');
 const JidParser = require('./src/utils/JidParser');
 const Media = require('./src/utils/Media');
 const StreamParser = require('./src/core/StreamParser');
@@ -63,6 +64,7 @@ module.exports.ResponseFormatter = ResponseFormatter;
 module.exports.TriggerDetector = TriggerDetector;
 module.exports.ImageDescriber = ImageDescriber;
 module.exports.WebAnswer = WebAnswer;
+module.exports.WebSearch = WebSearch;
 module.exports.JidParser = JidParser;
 module.exports.Media = Media;
 module.exports.StreamParser = StreamParser;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "alexa-ai",
-  "version": "2.1.1",
+  "version": "2.2.1",
   "description": "AI engine for the Alexa WhatsApp bot: DeepAI-powered chat with PostgreSQL-backed long-term memory, cross-chat identity (@lid <-> phone), vision/OCR, image generation and web search.",
   "main": "index.js",
   "scripts": {
@@ -40,6 +40,7 @@
     "index.js",
     "src/",
     "examples/",
+    "test/",
     "README.md",
     "CHANGELOG.md",
     "LICENSE"