explorbot 0.2.0 → 0.2.2

package/dist/src/commands/context-html-command.js

@@ -6,7 +6,7 @@ export class ContextHtmlCommand extends BaseCommand {
     description = 'Print combined HTML snapshot for current page';
     async execute(_args) {
         const explorer = this.explorBot.getExplorer();
-        const manager = explorer.getStateManager();
+        const manager = this.explorBot.stateManager();
         const state = manager.getCurrentState();
         if (!state) {
             throw new Error('No active page to snapshot');
@@ -14,7 +14,7 @@ export class ContextHtmlCommand extends BaseCommand {
         let actionResult = ActionResult.fromState(state);
         if (!actionResult.html || actionResult.html.trim().length < 100) {
             tag('info').log('Capturing fresh page content...');
-            actionResult = await explorer.createAction().capturePageState();
+            actionResult = await explorer.capture();
         }
         const html = await actionResult.combinedHtml();
         if (!html) {

package/dist/src/commands/context-knowledge-command.js

@@ -8,7 +8,7 @@ export class ContextKnowledgeCommand extends BaseCommand {
     description = 'Print all matching knowledge for current page';
     async execute(_args) {
         const explorer = this.explorBot.getExplorer();
-        const state = explorer.getStateManager().getCurrentState();
+        const state = this.explorBot.stateManager().getCurrentState();
         if (!state) {
             throw new Error('No active page');
         }

package/dist/src/commands/drill-command.js

@@ -10,7 +10,7 @@ export class DrillCommand extends BaseCommand {
     async execute(args) {
         const knowledgePath = this.parseKnowledgeArg(args);
         const maxComponents = this.parseMaxArg(args);
-        const state = this.explorBot.getExplorer().getStateManager().getCurrentState();
+        const state = this.explorBot.stateManager().getCurrentState();
         if (!state) {
             throw new Error('No active page to drill');
         }

package/dist/src/commands/explore-command.js

@@ -4,6 +4,7 @@ import { outputPath } from '../config.js';
 import { normalizeUrl } from '../state-manager.js';
 import { Stats } from '../stats.js';
 import { TestResult } from '../test-plan.js';
+import { browserErrorMessage } from "../utils/browser-errors.js";
 import { getCliName } from "../utils/cli-name.js";
 import { ErrorPageError, getStateErrorPageError } from "../utils/error-page.js";
 import { tag } from '../utils/logger.js';
@@ -34,7 +35,7 @@ export class ExploreCommand extends BaseCommand {
     oldTestRefs = new Set();
     priorityFilter;
     getCurrentPageUrl() {
-        const state = this.explorBot.getExplorer().getStateManager().getCurrentState();
+        const state = this.explorBot.stateManager().getCurrentState();
         return state?.fullUrl || state?.url;
     }
     async execute(args) {
@@ -53,7 +54,7 @@ export class ExploreCommand extends BaseCommand {
         Stats.mode ??= 'explore';
         Stats.focus ??= feature;
         const mainUrl = this.getCurrentPageUrl();
-        const error = getStateErrorPageError(this.explorBot.getExplorer().getStateManager().getCurrentState());
+        const error = getStateErrorPageError(this.explorBot.stateManager().getCurrentState());
         if (error) {
             tag('warning').log(error.message);
             return;
@@ -72,7 +73,7 @@ export class ExploreCommand extends BaseCommand {
             return;
         }
         if (mainUrl)
-            await this.explorBot.visit(mainUrl);
+            await this.explorBot.visit(mainUrl).catch((err) => tag('warning').log(`Could not return to ${mainUrl}: ${browserErrorMessage(err)}`));
         const savedPath = this.explorBot.savePlans(this.completedPlans);
         this.printResults();
         await this.explorBot.printSessionAnalysis();

package/dist/src/commands/freesail-command.js

@@ -31,7 +31,7 @@ export class FreesailCommand extends BaseCommand {
         await loop(async (ctx) => {
             if (maxTests != null && testsRun >= maxTests)
                 ctx.stop();
-            const stateManager = this.explorBot.getExplorer().getStateManager();
+            const stateManager = this.explorBot.stateManager();
             const state = stateManager.getCurrentState();
             if (state && !Researcher.getCachedResearch(state)) {
                 await this.explorBot.agentResearcher().research(state, { deep: true, screenshot: true });
@@ -63,7 +63,7 @@ export class FreesailCommand extends BaseCommand {
                 return;
             }
             tag('info').log(`Navigating to: ${suggestion.target} - ${suggestion.reason}`);
-            await this.explorBot.openFreshTab();
+            await this.explorBot.openTab();
             await this.explorBot.visit(suggestion.target);
             this.explorBot.clearPlan();
         }, { maxAttempts: Number.POSITIVE_INFINITY });

package/dist/src/commands/learn-command.js

@@ -11,11 +11,11 @@ export class LearnCommand extends BaseCommand {
         if (!note) {
             const AddKnowledge = (await import('../components/AddKnowledge.js')).default;
             const explorer = this.explorBot.getExplorer();
-            const state = explorer.getStateManager().getCurrentState();
+            const state = this.explorBot.stateManager().getCurrentState();
             const initialUrl = state?.url || '';
             const { unmount } = render(React.createElement(AddKnowledge, {
                 initialUrl,
-                knowledgeTracker: explorer.getKnowledgeTracker(),
+                knowledgeTracker: this.explorBot.knowledgeTracker(),
                 onComplete: () => unmount(),
                 onCancel: () => unmount(),
             }), {
@@ -25,12 +25,12 @@ export class LearnCommand extends BaseCommand {
             return;
         }
         const explorer = this.explorBot.getExplorer();
-        const state = explorer.getStateManager().getCurrentState();
+        const state = this.explorBot.stateManager().getCurrentState();
         if (!state) {
             throw new Error('No active page to attach knowledge');
         }
         const targetUrl = state.url || state.fullUrl || '/';
-        explorer.getKnowledgeTracker().addKnowledge(targetUrl, note);
+        this.explorBot.knowledgeTracker().addKnowledge(targetUrl, note);
         tag('success').log('Knowledge saved for current page');
     }
 }

package/dist/src/commands/path-command.js

@@ -7,7 +7,7 @@ export class PathCommand extends BaseCommand {
     async execute(args) {
         const { opts } = this.parseArgs(args);
         const showLinks = !!opts.links;
-        const stateManager = this.explorBot.getExplorer().getStateManager();
+        const stateManager = this.explorBot.stateManager();
         const history = stateManager.getStateHistory();
         if (history.length === 0) {
             tag('multiline').log('No navigation history yet.');

package/dist/src/commands/research-command.js

@@ -23,7 +23,7 @@ export class ResearchCommand extends BaseCommand {
         if (target) {
             await this.explorBot.agentNavigator().visit(target);
         }
-        const state = this.explorBot.getExplorer().getStateManager().getCurrentState();
+        const state = this.explorBot.stateManager().getCurrentState();
         if (!state) {
             throw new Error('No active page to research');
         }

package/dist/src/commands/test-command.js

@@ -48,7 +48,7 @@ export class TestCommand extends BaseCommand {
                 toExecute.push(...matching);
             }
             else {
-                const state = this.explorBot.getExplorer().getStateManager().getCurrentState();
+                const state = this.explorBot.stateManager().getCurrentState();
                 if (!state) {
                     throw new Error('No page loaded. Please navigate to a page first.');
                 }

package/dist/src/components/App.js

@@ -47,7 +47,7 @@ export function App({ explorBot, initialShowInput = false, exitOnEmptyInput = fa
                 userInputPromiseRef.current = { resolve, reject };
             });
         });
-        const manager = explorBot.getExplorer().getStateManager();
+        const manager = explorBot.stateManager();
         unsubscribe = manager.onStateChange((transition) => {
             if (mounted) {
                 setLastTransition(transition);

package/dist/src/config.d.ts

@@ -1,3 +1,4 @@
+export declare const PROVIDERS: Record<string, () => Promise<(modelId: string) => any>>;
 interface PlaywrightConfig {
     browser: 'chromium' | 'firefox' | 'webkit';
     url: string;
@@ -204,6 +205,7 @@ interface ExplorbotConfig {
     };
     experience?: {
         maxReadLines?: number;
+        disabled?: boolean;
     };
     reporter?: ReporterConfig;
     api?: ApiConfig;
@@ -213,14 +215,17 @@ interface ExplorbotConfig {
 }
 type RuleEntry = string | Record<string, string>;
 export declare const EXPLORBOT_CONFIG_PATHS: string[];
+export declare const EXPLORBOT_ENV_VARS: EnvVar[];
 export type { ExplorbotConfig, PlaywrightConfig, AIConfig, HtmlConfig, ActionConfig, AgentConfig, AgentsConfig, HistorianAgentConfig, ResearcherAgentConfig, NavigatorAgentConfig, PlannerAgentConfig, RerunnerAgentConfig, HealRecipe, Hook, HookConfig, HooksConfig, PlaywrightHook, CodeceptJSHook, HookPatternMap, RuleEntry, ReporterConfig, ApiConfig, WebConfig, ApiHookFn, };
 export declare class ConfigParser {
     static instance: ConfigParser;
+    static recommended: Record<string, Record<string, string>> | null;
     config: ExplorbotConfig | null;
     configPath: string | null;
     runtimeBaseUrlOverride: string | null;
     constructor();
     static loadEnv(filePath: string): void;
+    static recommendedModels(): Record<string, Record<string, string>>;
     static getInstance(): ConfigParser;
     loadConfig(options?: {
         config?: string;
@@ -239,6 +244,7 @@ export declare class ConfigParser {
     static setupTestConfig(): void;
     static getTestDirectories(): string[];
     static cleanupAllTestDirectories(): void;
+    buildEnvConfig(baseUrl: string | undefined, outputRoot: string): Promise<ExplorbotConfig>;
     findConfigFile(): string | null;
     loadConfigModule(configPath: string): Promise<any>;
     resolveConfig(config: ExplorbotConfig, options?: {
@@ -251,3 +257,14 @@ export declare class ConfigParser {
     ensureDirectory(path: string): void;
 }
 export declare function outputPath(...segments: string[]): string;
+export declare function resolveModel(spec: string, role?: ModelRole): Promise<any>;
+export declare function resolveOutputRoot(): string;
+export declare function materializeKnowledge(outputRoot: string): void;
+export declare function createModel(provider: string, modelId: string): Promise<any>;
+type ModelRole = 'model' | 'visionModel' | 'agenticModel';
+interface EnvVar {
+    name: string;
+    description: string;
+    required?: boolean;
+}
+export type { ModelRole, EnvVar };

package/dist/src/config.js

@@ -6,10 +6,22 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
     }
     return path;
 };
-import { existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
-import path, { dirname, join, resolve } from 'node:path';
+import { copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import path, { basename, dirname, join, resolve } from 'node:path';
 import { parseEnv } from 'node:util';
+import matter from 'gray-matter';
 import { log } from './utils/logger.js';
+export const PROVIDERS = {
+    openai: async () => (await import('@ai-sdk/openai')).createOpenAI(),
+    anthropic: async () => (await import('@ai-sdk/anthropic')).createAnthropic(),
+    google: async () => (await import('@ai-sdk/google')).createGoogleGenerativeAI(),
+    groq: async () => (await import('@ai-sdk/groq')).createGroq(),
+    mistral: async () => (await import('@ai-sdk/mistral')).createMistral(),
+    openrouter: async () => (await import('@openrouter/ai-sdk-provider')).createOpenRouter(),
+    sambanova: async () => (await import('sambanova-ai-provider')).createSambaNova(),
+};
+let cachedOutputRoot = null;
 const config = {
     playwright: {
         browser: 'chromium',
@@ -20,8 +32,21 @@ const config = {
     },
 };
 export const EXPLORBOT_CONFIG_PATHS = ['explorbot.config.js', 'explorbot.config.mjs', 'explorbot.config.ts'];
+export const EXPLORBOT_ENV_VARS = [
+    { name: 'EXPLORBOT_AI_PROVIDER', required: true, description: 'Provider name; fills every model role from its recommended models. Turns on config-free mode' },
+    { name: 'EXPLORBOT_AI_MODEL', description: 'Pins the main model — a model id for the provider, or a standalone provider/model-id' },
+    { name: 'EXPLORBOT_URL', required: true, description: 'Base URL to test; the API boat reads it as the base endpoint' },
+    { name: 'EXPLORBOT_VISION_MODEL', description: 'Screenshot analysis; overrides the provider recommendation' },
+    { name: 'EXPLORBOT_AGENTIC_MODEL', description: 'Captain and Pilot decisions; overrides the provider recommendation' },
+    { name: 'EXPLORBOT_OUTPUT', description: 'Output root for states, plans, research, and reports. Defaults to a fresh temp directory' },
+    { name: 'EXPLORBOT_KNOWLEDGE', description: 'Inline knowledge text, applied to every page' },
+    { name: 'EXPLORBOT_KNOWLEDGE_FILE', description: 'Path to a knowledge markdown file' },
+    { name: 'EXPLORBOT_API_SPEC', description: 'OpenAPI spec path for the API boat' },
+    { name: 'EXPLORBOT_NO_BANNER', description: 'Suppress the startup banner, for machine-readable output' },
+];
 export class ConfigParser {
     static instance;
+    static recommended = null;
     config = null;
     configPath = null;
     runtimeBaseUrlOverride = null;
@@ -32,6 +57,10 @@ export class ConfigParser {
             return;
         Object.assign(process.env, parseEnv(readFileSync(resolved, 'utf8')));
     }
+    static recommendedModels() {
+        ConfigParser.recommended ||= JSON.parse(readFileSync(new URL('../models.json', import.meta.url), 'utf8'));
+        return ConfigParser.recommended;
+    }
     static getInstance() {
         if (!ConfigParser.instance) {
             ConfigParser.instance = new ConfigParser();
@@ -54,18 +83,25 @@ export class ConfigParser {
         ConfigParser.loadEnv('.env');
         try {
             const resolvedPath = options?.config || this.findConfigFile();
-            if (!resolvedPath) {
-                throw new Error('No configuration file found. Please create explorbot.config.js or explorbot.config.ts');
+            let loadedConfig = null;
+            let sourcePath = resolvedPath;
+            if (resolvedPath) {
+                const configModule = await this.loadConfigModule(resolvedPath);
+                loadedConfig = configModule.default || configModule;
+                if (!loadedConfig) {
+                    throw new Error('Configuration file is empty or invalid');
+                }
+                log(`Configuration loaded from: ${resolvedPath}`);
             }
-            const configModule = await this.loadConfigModule(resolvedPath);
-            const loadedConfig = configModule.default || configModule;
-            if (!loadedConfig) {
-                throw new Error('Configuration file is empty or invalid');
+            if (!resolvedPath) {
+                const outputRoot = resolveOutputRoot();
+                loadedConfig = await this.buildEnvConfig(options?.baseUrl, outputRoot);
+                sourcePath = join(outputRoot, 'explorbot.config.js');
+                log(`Configuration built from EXPLORBOT_* environment variables. Output: ${outputRoot}`);
             }
             this.config = this.resolveConfig(loadedConfig, options);
             this.runtimeBaseUrlOverride = options?.baseUrl || null;
-            this.configPath = resolvedPath;
-            log(`Configuration loaded from: ${resolvedPath}`);
+            this.configPath = sourcePath;
             // Restore original directory after successful config load
             if (options?.path && originalCwd !== process.cwd()) {
                 process.chdir(originalCwd);
@@ -119,6 +155,7 @@ export class ConfigParser {
     }
     // For testing purposes only
     static resetForTesting() {
+        cachedOutputRoot = null;
         if (ConfigParser.instance) {
             ConfigParser.instance.config = null;
             ConfigParser.instance.configPath = null;
@@ -169,6 +206,51 @@ export class ConfigParser {
             // Ignore cleanup errors
         }
     }
+    async buildEnvConfig(baseUrl, outputRoot) {
+        const provider = process.env.EXPLORBOT_AI_PROVIDER;
+        const modelSpec = process.env.EXPLORBOT_AI_MODEL;
+        if (!provider && !modelSpec) {
+            throw new Error('No configuration file found. Please create explorbot.config.js or set EXPLORBOT_URL and EXPLORBOT_AI_PROVIDER environment variables');
+        }
+        if (modelSpec && !provider && !modelSpec.includes('/')) {
+            throw new Error('EXPLORBOT_AI_MODEL needs a provider — set EXPLORBOT_AI_PROVIDER, or write it as "provider/model-id"');
+        }
+        const url = process.env.EXPLORBOT_URL || baseUrl;
+        if (!url) {
+            throw new Error('No URL to explore. Set EXPLORBOT_URL or pass a URL to the command');
+        }
+        materializeKnowledge(outputRoot);
+        let model;
+        if (provider && modelSpec)
+            model = await createModel(provider, modelSpec);
+        if (provider && !modelSpec)
+            model = await resolveModel(provider, 'model');
+        if (!provider)
+            model = await resolveModel(modelSpec, 'model');
+        const ai = {
+            model,
+            agents: { historian: { enabled: false } },
+        };
+        let recommended = {};
+        if (provider)
+            recommended = ConfigParser.recommendedModels()[provider] || {};
+        const visionSpec = process.env.EXPLORBOT_VISION_MODEL;
+        if (visionSpec)
+            ai.visionModel = await resolveModel(visionSpec, 'visionModel');
+        if (!visionSpec && recommended.visionModel)
+            ai.visionModel = await resolveModel(provider, 'visionModel');
+        const agenticSpec = process.env.EXPLORBOT_AGENTIC_MODEL;
+        if (agenticSpec)
+            ai.agenticModel = await resolveModel(agenticSpec, 'agenticModel');
+        if (!agenticSpec && recommended.agenticModel)
+            ai.agenticModel = await resolveModel(provider, 'agenticModel');
+        return {
+            playwright: { browser: 'chromium', url, show: false },
+            ai,
+            dirs: { knowledge: 'knowledge', experience: 'experience', output: '.' },
+            experience: { disabled: true },
+        };
+    }
     findConfigFile() {
         const possiblePaths = [...EXPLORBOT_CONFIG_PATHS, 'config/explorbot.config.js', 'config/explorbot.config.mjs', 'config/explorbot.config.ts', 'src/config/explorbot.config.js', 'src/config/explorbot.config.mjs', 'src/config/explorbot.config.ts'];
         for (const path of possiblePaths) {
@@ -268,3 +350,55 @@ export class ConfigParser {
 export function outputPath(...segments) {
     return path.join(ConfigParser.getInstance().getOutputDir(), ...segments);
 }
+export async function resolveModel(spec, role = 'model') {
+    const separator = spec.indexOf('/');
+    if (separator > 0) {
+        return createModel(spec.slice(0, separator), spec.slice(separator + 1));
+    }
+    const recommended = ConfigParser.recommendedModels()[spec];
+    if (!recommended) {
+        throw new Error(`No recommended models for "${spec}". Write it as "provider/model-id", or use a provider with recommendations: ${Object.keys(ConfigParser.recommendedModels()).join(', ')}`);
+    }
+    const modelId = recommended[role];
+    if (!modelId) {
+        throw new Error(`Provider "${spec}" has no recommended ${role}. Set it explicitly as "provider/model-id".`);
+    }
+    return createModel(spec, modelId);
+}
+export function resolveOutputRoot() {
+    if (cachedOutputRoot)
+        return cachedOutputRoot;
+    const configured = process.env.EXPLORBOT_OUTPUT;
+    if (!configured) {
+        cachedOutputRoot = mkdtempSync(join(tmpdir(), 'explorbot-'));
+        return cachedOutputRoot;
+    }
+    cachedOutputRoot = resolve(configured);
+    mkdirSync(cachedOutputRoot, { recursive: true });
+    return cachedOutputRoot;
+}
+export function materializeKnowledge(outputRoot) {
+    const inline = process.env.EXPLORBOT_KNOWLEDGE;
+    const knowledgeFile = process.env.EXPLORBOT_KNOWLEDGE_FILE;
+    if (!inline && !knowledgeFile)
+        return;
+    const knowledgeDir = join(outputRoot, 'knowledge');
+    mkdirSync(knowledgeDir, { recursive: true });
+    if (inline) {
+        writeFileSync(join(knowledgeDir, 'global.md'), matter.stringify(inline, { url: '*', endpoint: '*' }));
+    }
+    if (!knowledgeFile)
+        return;
+    const source = resolve(knowledgeFile);
+    if (!existsSync(source)) {
+        throw new Error(`Knowledge file from EXPLORBOT_KNOWLEDGE_FILE not found: ${source}`);
+    }
+    copyFileSync(source, join(knowledgeDir, basename(source)));
+}
+export async function createModel(provider, modelId) {
+    const factory = PROVIDERS[provider];
+    if (!factory) {
+        throw new Error(`Unknown AI provider "${provider}". Supported providers: ${Object.keys(PROVIDERS).join(', ')}`);
+    }
+    return (await factory())(modelId);
+}

package/dist/src/experience-tracker.js

@@ -35,7 +35,7 @@ export class ExperienceTracker {
     constructor(knowledgeTracker, options = {}) {
         const configParser = ConfigParser.getInstance();
         const config = configParser.getConfig();
-        this.disabled = options.disabled ?? false;
+        this.disabled = options.disabled ?? config.experience?.disabled ?? false;
         this.knowledgeTracker = knowledgeTracker;
         // Resolve experience directory relative to the config file location (project root)
         this.experienceDir = configParser.resolveProjectDir(config.dirs?.experience || 'experience');

package/dist/src/explorbot.d.ts

@@ -1,3 +1,4 @@
+import type { AgentDeps } from './ai/agent.js';
 import { Captain } from './ai/captain.js';
 import { Driller } from './ai/driller.js';
 import { ExperienceCompactor } from './ai/experience-compactor.js';
@@ -12,12 +13,15 @@ import { Rerunner } from './ai/rerunner.js';
 import { Researcher } from './ai/researcher.js';
 import { SessionAnalyst } from './ai/session-analyst.js';
 import { Tester } from './ai/tester.js';
+import { RequestStore } from './api/request-store.js';
 import type { ExplorbotConfig } from './config.js';
 import { ConfigParser } from './config.js';
 import { ExperienceTracker } from './experience-tracker.js';
 import Explorer from './explorer.js';
 import { KnowledgeTracker } from './knowledge-tracker.js';
-import { WebPageState } from './state-manager.js';
+import { PlaywrightRecorder } from './playwright-recorder.js';
+import { Reporter } from './reporter.js';
+import { StateManager, WebPageState } from './state-manager.js';
 import type { Suite } from './suite.js';
 import { Plan, type Test } from './test-plan.js';
 export interface ExplorBotOptions {
@@ -29,7 +33,7 @@ export interface ExplorBotOptions {
     show?: boolean;
     headless?: boolean;
     incognito?: boolean;
-    session?: string;
+    session?: string | boolean;
 }
 export type UserResolveFunction = (error?: Error, showWelcome?: boolean) => Promise<string | null>;
 export declare class ExplorBot {
@@ -48,6 +52,10 @@ export declare class ExplorBot {
     lastReportedTestCount: number;
     _experienceTracker?: ExperienceTracker;
     _knowledgeTracker?: KnowledgeTracker;
+    _stateManager?: StateManager;
+    _reporter?: Reporter;
+    _requestStore?: RequestStore;
+    _playwrightRecorder?: PlaywrightRecorder;
     constructor(options?: ExplorBotOptions);
     get isExploring(): boolean;
     setUserResolve(fn: UserResolveFunction): void;
@@ -56,19 +64,19 @@ export declare class ExplorBot {
     stop(): Promise<void>;
     visitInitialState(): Promise<void>;
     visit(url: string): Promise<void>;
-    openFreshTab(): Promise<void>;
+    openTab(): Promise<void>;
     getCurrentState(): WebPageState | null;
     getExplorer(): Explorer;
     knowledgeTracker(): KnowledgeTracker;
     experienceTracker(): ExperienceTracker;
+    stateManager(): StateManager;
+    reporter(): Reporter;
+    requestStore(): RequestStore;
+    playwrightRecorder(): PlaywrightRecorder;
     getConfig(): ExplorbotConfig;
     getOptions(): ExplorBotOptions;
     getProvider(): AIProvider;
-    createAgent<T>(factory: (deps: {
-        explorer: Explorer;
-        ai: AIProvider;
-        config: ExplorbotConfig;
-    }) => T): T;
+    createAgent<T>(factory: (deps: AgentDeps) => T): T;
     agentResearcher(): Researcher;
     agentNavigator(): Navigator;
     agentPlanner(): Planner;
@@ -103,4 +111,5 @@ export declare class ExplorBot {
     setCurrentPlan(plan?: Plan): void;
     getSessionTests(): Test[];
     printSessionAnalysis(): Promise<void>;
+    isHistorianEnabled(): boolean;
 }