explorbot 0.1.32-beta.1 → 0.2.1

package/dist/src/utils/html.js

@@ -67,8 +67,10 @@ const INTERACTIVE_EVENT_ATTRIBUTES = new Set(['onclick', 'onchange', 'onblur', '
 const HIDDEN_CLASSES = new Set(['hidden', 'invisible', 'd-none', 'hide', 'dn', 'u-hidden', 'is-hidden', 'visually-hidden', 'sr-only', 'screen-reader-only', 'visuallyhidden', 'opacity-0']);
 export const EXPLORBOT_ATTRS = {
     area: 'data-explorbot-area',
+    coveredBy: 'data-explorbot-covered-by',
     context: 'data-explorbot-context',
     eidx: 'data-explorbot-eidx',
+    hit: 'data-explorbot-hit',
     variant: 'data-explorbot-variant',
 };
 export const HTML_SELECTORS = {
@@ -139,13 +141,41 @@ export const ELEMENT_EXTRACTION_CONFIG = {
         semanticContextContainer: HTML_SELECTORS.semanticContextContainer,
     },
 };
+export function captureHtmlForSnapshot() {
+    const clone = document.documentElement.cloneNode(true);
+    const liveControls = Array.from(document.querySelectorAll('input, textarea, select'));
+    const clonedControls = Array.from(clone.querySelectorAll('input, textarea, select'));
+    for (let i = 0; i < liveControls.length; i++) {
+        const source = liveControls[i];
+        const target = clonedControls[i];
+        if (!target)
+            continue;
+        if (source instanceof HTMLInputElement || source instanceof HTMLTextAreaElement) {
+            target.setAttribute('data-explorbot-value', source.value);
+        }
+        if (source instanceof HTMLInputElement && (source.type === 'checkbox' || source.type === 'radio')) {
+            let checked = 'false';
+            if (source.checked)
+                checked = 'true';
+            target.setAttribute('data-explorbot-checked', checked);
+        }
+        if (source instanceof HTMLSelectElement) {
+            target.setAttribute('data-explorbot-value', Array.from(source.selectedOptions)
+                .map((option) => option.value)
+                .join(','));
+        }
+    }
+    return clone.outerHTML;
+}
 export function extractElementData(el, config) {
     const cfg = config ||
         {
             attrs: {
                 area: 'data-explorbot-area',
+                coveredBy: 'data-explorbot-covered-by',
                 context: 'data-explorbot-context',
                 eidx: 'data-explorbot-eidx',
+                hit: 'data-explorbot-hit',
                 variant: 'data-explorbot-variant',
             },
             codeEditorMarkers: ['monaco', 'codemirror', 'ace', 'ace_editor', 'code'],
@@ -223,6 +253,43 @@ export function extractElementData(el, config) {
             tokens.add('navigates');
         return Array.from(tokens).slice(0, 8);
     }
+    function describeOverlappingElement(target) {
+        const parts = [target.tagName.toLowerCase()];
+        const role = target.getAttribute('role');
+        const ariaLabel = target.getAttribute('aria-label');
+        const id = target.getAttribute('id');
+        const className = (target.getAttribute('class') || '').split(/\s+/).filter(Boolean).slice(0, 3).join('.');
+        if (id)
+            parts.push(`#${id.slice(0, 40)}`);
+        if (className)
+            parts.push(`.${className.slice(0, 80)}`);
+        if (role)
+            parts.push(`[role="${role.slice(0, 40)}"]`);
+        if (ariaLabel)
+            parts.push(`[aria-label="${ariaLabel.slice(0, 80)}"]`);
+        return parts.join('');
+    }
+    function inspectHitTarget(target, rect) {
+        const viewportPoints = [
+            { x: rect.left + rect.width / 2, y: rect.top + rect.height / 2 },
+            { x: rect.left + Math.min(rect.width - 1, Math.max(1, rect.width * 0.25)), y: rect.top + Math.min(rect.height - 1, Math.max(1, rect.height * 0.25)) },
+            { x: rect.left + Math.min(rect.width - 1, Math.max(1, rect.width * 0.75)), y: rect.top + Math.min(rect.height - 1, Math.max(1, rect.height * 0.75)) },
+        ].filter((point) => point.x >= 0 && point.y >= 0 && point.x <= window.innerWidth && point.y <= window.innerHeight);
+        if (viewportPoints.length === 0) {
+            return { hit: 'offscreen' };
+        }
+        for (const point of viewportPoints) {
+            const top = document.elementFromPoint(point.x, point.y);
+            if (!top)
+                continue;
+            if (top === target || target.contains(top)) {
+                return { hit: 'target' };
+            }
+        }
+        const centerPoint = viewportPoints[0];
+        const top = document.elementFromPoint(centerPoint.x, centerPoint.y);
+        return { hit: 'covered', coveredBy: top ? describeOverlappingElement(top) : undefined };
+    }
     function isEmbeddedCodeEditorFrame(target) {
         const src = (target.getAttribute('src') || '').toLowerCase();
         const markerSelector = cfg.codeEditorMarkers.map((marker) => `[class*="${marker}"]`).join(', ');
@@ -329,6 +396,10 @@ export function extractElementData(el, config) {
     allAttrs[cfg.attrs.area] = areaHints.join('|');
     allAttrs[cfg.attrs.context] = findContextLabel(el);
     allAttrs[cfg.attrs.variant] = collectVariantHints(el).join('|');
+    const hitTarget = inspectHitTarget(el, rect);
+    allAttrs[cfg.attrs.hit] = hitTarget.hit;
+    if (hitTarget.coveredBy)
+        allAttrs[cfg.attrs.coveredBy] = hitTarget.coveredBy;
     return {
         tag: el.tagName.toLowerCase(),
         text: normalizeText(el.textContent || '').slice(0, cfg.maxTextLength),

package/dist/src/utils/markdown-files.d.ts

@@ -0,0 +1,10 @@
+export declare function loadMarkdownFiles(dir: string, options?: {
+    recursive?: boolean;
+    onError?: (filePath: string, error: unknown) => void;
+}): MarkdownFile[];
+export interface MarkdownFile {
+    filePath: string;
+    content: string;
+    data: Record<string, any>;
+    mtime: Date;
+}

package/dist/src/utils/markdown-files.js

@@ -0,0 +1,21 @@
+import { existsSync, readFileSync, readdirSync, statSync } from 'node:fs';
+import { join } from 'node:path';
+import matter from 'gray-matter';
+export function loadMarkdownFiles(dir, options = {}) {
+    if (!existsSync(dir))
+        return [];
+    const results = [];
+    const files = readdirSync(dir, { recursive: options.recursive === true })
+        .filter((file) => typeof file === 'string' && file.endsWith('.md'))
+        .map((file) => join(dir, file));
+    for (const filePath of files) {
+        try {
+            const parsed = matter(readFileSync(filePath, 'utf8'));
+            results.push({ filePath, content: parsed.content, data: parsed.data, mtime: statSync(filePath).mtime });
+        }
+        catch (error) {
+            options.onError?.(filePath, error);
+        }
+    }
+    return results;
+}

package/dist/src/utils/markdown-query.d.ts

@@ -30,11 +30,17 @@ export declare class MarkdownQuery {
     get(): string;
     toJson(): Record<string, string>[];
     replace(content: string): string;
+    replaceEach(replacer: (match: MarkdownQuery, index: number) => string): string;
     count(): number;
     first(): MarkdownQuery;
     last(): MarkdownQuery;
     before(): MarkdownQuery;
     after(): MarkdownQuery;
     each(): MarkdownQuery[];
+    meta(): Array<{
+        type: string;
+        depth: number | null;
+        text: string;
+    }>;
 }
 export declare function mdq(source: string): MarkdownQuery;

package/dist/src/utils/markdown-query.js

@@ -341,6 +341,9 @@ export class MarkdownQuery {
         return results;
     }
     replace(content) {
+        return this.replaceEach(() => content);
+    }
+    replaceEach(replacer) {
         const sorted = [...this.matches].sort((a, b) => a.start - b.start);
         const kept = [];
         let lastEnd = -1;
@@ -350,10 +353,11 @@ export class MarkdownQuery {
             kept.push(range);
             lastEnd = range.start + range.length;
         }
+        const replacements = kept.map((range, index) => replacer(new MarkdownQuery(this.source, [range]), index));
         let result = this.source;
         for (let i = kept.length - 1; i >= 0; i--) {
             const range = kept[i];
-            result = result.slice(0, range.start) + content + result.slice(range.start + range.length);
+            result = result.slice(0, range.start) + replacements[i] + result.slice(range.start + range.length);
         }
         return result;
     }
@@ -386,6 +390,15 @@ export class MarkdownQuery {
     each() {
         return this.matches.map((m) => new MarkdownQuery(this.source, [m]));
     }
+    meta() {
+        return this.matches.map((range) => {
+            const token = range.token;
+            let depth = null;
+            if (token.type === 'heading')
+                depth = token.depth;
+            return { type: token.type, depth, text: getTokenText(range.token) };
+        });
+    }
 }
 export function mdq(source) {
     return new MarkdownQuery(source);

package/dist/src/utils/page-readiness.d.ts

@@ -1,4 +1,5 @@
 export declare function waitForPageReadiness(page: any, options?: PageReadinessOptions): Promise<void>;
+export declare function sleep(ms: number): Promise<void>;
 interface PageReadinessOptions {
     timeout?: number;
     spinnerSelectors?: string[];

package/dist/src/utils/page-readiness.js

@@ -43,6 +43,6 @@ function waitForPageBodyContent(page, timeout) {
     }, undefined, { timeout })
         .catch(() => { });
 }
-function sleep(ms) {
+export function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/dist/src/utils/secrets.js

@@ -1,4 +1,5 @@
 const MIN_SECRET_LENGTH = 4;
+const SECRET_NAME_TOKENS = ['password', 'passwd', 'secret', 'token', 'apikey', 'api_key', 'credential', 'private_key', 'privatekey', 'access_key', 'jwt', 'auth', 'bearer', 'authorization', 'cert', 'certificate'];
 const secretValues = new Set();
 export function registerSecret(value) {
     if (!value)
@@ -11,7 +12,7 @@ export function redactSecrets(text) {
     if (!text)
         return text;
     let result = text;
-    for (const value of secretValues) {
+    for (const value of [...secretValues].sort((a, b) => b.length - a.length)) {
         if (!result.includes(value))
             continue;
         result = result.split(value).join('***REDACTED***');
@@ -21,7 +22,6 @@ export function redactSecrets(text) {
 export function clearRegisteredSecrets() {
     secretValues.clear();
 }
-const SECRET_NAME_TOKENS = ['password', 'passwd', 'secret', 'token', 'apikey', 'api_key', 'credential', 'private_key', 'privatekey', 'access_key'];
 export function isSecretName(name) {
     const lower = name.toLowerCase();
     return SECRET_NAME_TOKENS.some((token) => lower.includes(token));

package/dist/src/utils/strings.d.ts

@@ -1,3 +1,5 @@
 export declare function truncateJson(input: any): string;
+export declare function slugify(text: string): string;
+export declare function normalizeInlineText(text: string): string;
 export declare function sanitizeFilename(name: string): string;
 export declare function safeFilename(name: string, ext?: string, maxBytes?: number): string;

package/dist/src/utils/strings.js

@@ -5,6 +5,16 @@ export function truncateJson(input) {
     const str = JSON.stringify(input);
     return str.length <= 80 ? str : `${str.slice(0, 77)}...`;
 }
+export function slugify(text) {
+    return text
+        .replace(/[^a-zA-Z0-9_]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_|_$/g, '')
+        .toLowerCase();
+}
+export function normalizeInlineText(text) {
+    return text.normalize('NFKC').replace(/\s+/g, ' ').trim();
+}
 export function sanitizeFilename(name) {
     return name
         .toLowerCase()

package/dist/src/utils/test-files.js

@@ -64,7 +64,7 @@ export async function dryRunTestFile(filePath) {
             Playwright: { browser: config.playwright.browser, url: config.playwright.url },
         },
     };
-    global.output_dir = path.join(projectRoot, 'output', 'states');
+    global.output_dir = ConfigParser.getInstance().getStatesDir();
     global.codecept_dir = projectRoot;
     codeceptjs.container.create(codeceptConfig, {});
     await codeceptjs.recorder.start();

package/dist/src/utils/web-annotate.d.ts

@@ -0,0 +1,5 @@
+import { WebElement } from './web-element.js';
+export declare function annotatePageElements(page: any): Promise<{
+    ariaSnapshot: string;
+    elements: WebElement[];
+}>;

package/dist/src/utils/web-annotate.js

@@ -0,0 +1,58 @@
+import { ELEMENT_EXTRACTION_CONFIG, getElementDataExtractorSource } from "./html.js";
+import { createDebug } from './logger.js';
+import { WebElement } from "./web-element.js";
+const debugLog = createDebug('explorbot:web-annotate');
+const REF_LINE_PATTERN = /^(\s*)-\s+(\w+)\s*(?:"([^"]*)")?.*?\[ref=(e\d+)\]/;
+const ANNOTATABLE_ROLES = new Set(['button', 'link', 'textbox', 'searchbox', 'checkbox', 'radio', 'switch', 'combobox', 'tab', 'menuitem', 'menuitemcheckbox', 'menuitemradio', 'option', 'slider', 'spinbutton', 'treeitem']);
+function parseAriaRefs(ariaSnapshot) {
+    const entries = [];
+    for (const line of ariaSnapshot.split('\n')) {
+        const match = line.match(REF_LINE_PATTERN);
+        if (!match)
+            continue;
+        if (!ANNOTATABLE_ROLES.has(match[2]))
+            continue;
+        entries.push({ role: match[2], name: match[3] || '', ref: match[4] });
+    }
+    return entries;
+}
+export async function annotatePageElements(page) {
+    const ariaSnapshot = await page.locator('body').ariaSnapshot({ mode: 'ai' });
+    const refEntries = parseAriaRefs(ariaSnapshot);
+    const byRole = new Map();
+    for (const { role, name, ref } of refEntries) {
+        let list = byRole.get(role);
+        if (!list) {
+            list = [];
+            byRole.set(role, list);
+        }
+        list.push({ name, ref });
+    }
+    const elements = [];
+    for (const [role, entries] of byRole) {
+        try {
+            const rawList = await page.getByRole(role).evaluateAll((domElements, [data, extractFnStr, config]) => {
+                const extract = new Function(`return ${extractFnStr}`)();
+                const results = [];
+                let ariaIdx = 0;
+                for (const el of domElements) {
+                    if (ariaIdx >= data.length)
+                        break;
+                    el.setAttribute(config.attrs.eidx, data[ariaIdx].ref);
+                    const elData = extract(el, config);
+                    if (elData)
+                        results.push(elData);
+                    ariaIdx++;
+                }
+                return results;
+            }, [entries, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG]);
+            for (const raw of rawList) {
+                elements.push(WebElement.fromRawData(raw, role));
+            }
+        }
+        catch {
+            debugLog(`Failed to annotate role=${role}`);
+        }
+    }
+    return { ariaSnapshot, elements };
+}

package/dist/src/utils/web-eidx.d.ts

@@ -0,0 +1,2 @@
+export declare function eidxInContainer(page: any, containerCss: string | null): Promise<string[]>;
+export declare function eidxByLocator(page: any, locator: string, container?: string | null): Promise<string | null>;

package/dist/src/utils/web-eidx.js

@@ -0,0 +1,20 @@
+import { ELEMENT_EXTRACTION_CONFIG } from "./html.js";
+export async function eidxInContainer(page, containerCss) {
+    const selector = containerCss ? `${containerCss} [${ELEMENT_EXTRACTION_CONFIG.attrs.eidx}]` : `[${ELEMENT_EXTRACTION_CONFIG.attrs.eidx}]`;
+    const elements = await page.locator(selector).all();
+    const result = [];
+    for (const el of elements) {
+        const attr = await el.getAttribute(ELEMENT_EXTRACTION_CONFIG.attrs.eidx).catch(() => null);
+        if (attr)
+            result.push(attr);
+    }
+    return result;
+}
+export async function eidxByLocator(page, locator, container) {
+    const base = container ? page.locator(container) : page;
+    const el = locator.startsWith('//') ? base.locator(`xpath=${locator}`) : base.locator(locator);
+    return el
+        .first()
+        .getAttribute(ELEMENT_EXTRACTION_CONFIG.attrs.eidx)
+        .catch(() => null);
+}

package/dist/src/utils/web-element.d.ts

@@ -1,4 +1,4 @@
-import { type RawElementData } from './html.js';
+import { EXPLORBOT_ATTRS, type RawElementData } from './html.js';
 import { type XPathMatch } from './xpath.js';
 export { extractElementData } from './html.js';
 export declare class WebElement {
@@ -26,6 +26,7 @@ export declare class WebElement {
     get keyAttrs(): string;
     get coordinates(): string;
     get eidx(): string | null;
+    ourAttr(name: keyof typeof EXPLORBOT_ATTRS): string | undefined;
     get isNavigationLink(): boolean;
     get filteredClasses(): string[];
     get areaHints(): string[];
@@ -36,6 +37,7 @@ export declare class WebElement {
     static fromPlaywrightLocator(locator: any): Promise<WebElement | null>;
     static fromEidx(page: any, eidx: string): Promise<WebElement | null>;
     static fromEidxList(page: any, eidxList: string[]): Promise<WebElement[]>;
+    static commonAncestor(page: any, eidxList: string[]): Promise<WebElement | null>;
     static findByXPath(html: string, xpath: string): Promise<{
         totalFound: number;
         elements: WebElement[];

package/dist/src/utils/web-element.js

@@ -39,6 +39,9 @@ export class WebElement {
     get eidx() {
         return this.attrs[EXPLORBOT_ATTRS.eidx] || this.attrs.eidx || null;
     }
+    ourAttr(name) {
+        return this.attrs[EXPLORBOT_ATTRS[name]];
+    }
     get isNavigationLink() {
         if (this.tag !== 'a')
             return false;
@@ -127,6 +130,35 @@ export class WebElement {
         }, [validEidxList, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG]);
         return rawList.map((d) => WebElement.fromRawData(d));
     }
+    static async commonAncestor(page, eidxList) {
+        const validEidxList = eidxList.filter((eidx) => /^e\d+$/i.test(eidx));
+        if (validEidxList.length < 2)
+            return null;
+        const raw = await page.evaluate(([list, extractFnStr, config]) => {
+            const extract = new Function(`return ${extractFnStr}`)();
+            const els = [];
+            for (const eidx of list) {
+                const el = document.querySelector(`[${config.attrs.eidx}="${eidx}"]`);
+                if (el && !els.includes(el))
+                    els.push(el);
+            }
+            if (els.length < 2)
+                return null;
+            const containsAll = (node) => els.every((el) => node.contains(el));
+            let ancestor = els[0].parentElement;
+            while (ancestor && !containsAll(ancestor))
+                ancestor = ancestor.parentElement;
+            if (!ancestor)
+                return null;
+            const tag = ancestor.tagName.toLowerCase();
+            if (tag === 'body' || tag === 'html')
+                return null;
+            return extract(ancestor, config);
+        }, [validEidxList, getElementDataExtractorSource(), ELEMENT_EXTRACTION_CONFIG]);
+        if (!raw)
+            return null;
+        return WebElement.fromRawData(raw);
+    }
     static async findByXPath(html, xpath) {
         const result = await evaluateXPath(html, xpath);
         if (result.error)

package/dist/src/utils/web-sandbox.d.ts

@@ -0,0 +1,4 @@
+export declare function sanitizeCodeBlock(code: string): string;
+export declare function hasPlaywrightCommands(code: string): boolean;
+export declare function playwrightSandbox(page: any, code: string): Promise<any>;
+export declare function codeceptJSSandbox(actor: any, codeOrFn: string | ((...args: any[]) => void)): void;

package/dist/src/utils/web-sandbox.js

@@ -0,0 +1,37 @@
+import { faker } from '@faker-js/faker';
+import { hopeThat, retryTo, tryTo, within } from 'codeceptjs/lib/effects';
+import step from 'codeceptjs/steps';
+const SHADOWED_GLOBALS = ['process', 'global', 'globalThis', 'fetch', 'Bun', 'require', 'module', 'exports'];
+const ALLOWED_COMMAND_HEADS = ['I.', 'page.', 'await page.', 'await I.'];
+const PLAYWRIGHT_COMMAND_HEADS = ['page.', 'await page.'];
+const PLAYWRIGHT_ARG_NAMES = ['page'];
+const CODECEPT_ARG_NAMES = ['I', 'tryTo', 'retryTo', 'within', 'hopeThat', 'step', 'faker'];
+export function sanitizeCodeBlock(code) {
+    return code
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => ALLOWED_COMMAND_HEADS.some((head) => line.startsWith(head)))
+        .join('\n');
+}
+export function hasPlaywrightCommands(code) {
+    return code.split('\n').some((line) => {
+        const trimmed = line.trim();
+        return PLAYWRIGHT_COMMAND_HEADS.some((head) => trimmed.startsWith(head));
+    });
+}
+export function playwrightSandbox(page, code) {
+    const run = createSandbox(PLAYWRIGHT_ARG_NAMES, `return (async () => { ${code} })()`);
+    return run(page);
+}
+export function codeceptJSSandbox(actor, codeOrFn) {
+    if (typeof codeOrFn === 'function') {
+        codeOrFn(actor, tryTo, retryTo, within, hopeThat, step, faker);
+        return;
+    }
+    const run = createSandbox(CODECEPT_ARG_NAMES, codeOrFn);
+    run(actor, tryTo, retryTo, within, hopeThat, step, faker);
+}
+function createSandbox(argNames, body) {
+    const fn = new Function(...argNames, ...SHADOWED_GLOBALS, `'use strict';\n${body}`);
+    return (...args) => fn(...args);
+}

package/models.json

@@ -0,0 +1,30 @@
+{
+  "openrouter": {
+    "model": "openai/gpt-oss-20b:nitro",
+    "visionModel": "google/gemma-4-31b-it:nitro",
+    "agenticModel": "google/gemma-4-31b-it:nitro"
+  },
+  "groq": {
+    "model": "openai/gpt-oss-20b",
+    "visionModel": "qwen/qwen3.6-27b",
+    "agenticModel": "qwen/qwen3.6-27b"
+  },
+  "openai": {
+    "model": "gpt-5.4-nano",
+    "visionModel": "gpt-5.4-nano",
+    "agenticModel": "gpt-5.6-luna"
+  },
+  "anthropic": {
+    "agenticModel": "claude-haiku-4-5-20251001"
+  },
+  "mistral": {
+    "model": "mistral-small-latest",
+    "visionModel": "mistral-small-latest",
+    "agenticModel": "mistral-large-latest"
+  },
+  "google": {
+    "model": "gemini-3.1-flash-lite",
+    "visionModel": "gemini-3.1-flash-lite",
+    "agenticModel": "gemini-3.5-flash"
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "explorbot",
-  "version": "0.1.32-beta.1",
+  "version": "0.2.1",
   "description": "CLI app built with React Ink, CodeceptJS, and Playwright",
   "license": "Elastic-2.0",
   "type": "module",
@@ -16,7 +16,19 @@
   "bin": {
     "explorbot": "./dist/bin/explorbot-cli.js"
   },
-  "files": ["dist/", "src/**/*.ts", "src/**/*.tsx", "bin/**/*.ts", "boat/api-tester/src/**/*.ts", "boat/doc-collector/src/**/*.ts", "boat/doc-collector/bin/**/*.ts", "boat/doc-collector/package.json", "rules/", "assets/sample-files/"],
+  "files": [
+    "dist/",
+    "src/**/*.ts",
+    "src/**/*.tsx",
+    "bin/**/*.ts",
+    "boat/api-tester/src/**/*.ts",
+    "boat/doc-collector/src/**/*.ts",
+    "boat/doc-collector/bin/**/*.ts",
+    "boat/doc-collector/package.json",
+    "rules/",
+    "assets/sample-files/",
+    "models.json"
+  ],
   "scripts": {
     "build": "bun run build:bin",
     "build:bin": "bun build bin/explorbot-cli.ts --outdir bin --target node --external commander --format esm",
@@ -43,7 +55,13 @@
     "check:fix": "biome check --write .",
     "langfuse:export": "bun run .claude/skills/explorbot-debug/langfuse-export.ts"
   },
-  "keywords": ["cli", "react", "ink", "codeceptjs", "playwright"],
+  "keywords": [
+    "cli",
+    "react",
+    "ink",
+    "codeceptjs",
+    "playwright"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/testomatio/explorbot"
@@ -51,7 +69,9 @@
   "author": "",
   "dependencies": {
     "@ai-sdk/anthropic": "^4.0",
+    "@ai-sdk/google": "^4.0.18",
     "@ai-sdk/groq": "^4.0",
+    "@ai-sdk/mistral": "^4.0.13",
     "@ai-sdk/openai": "^4.0",
     "@ai-sdk/otel": "^1.0.2",
     "@axe-core/playwright": "^4.11.0",