browser-use 0.1.0 → 0.3.0

package/dist/telemetry/views.d.ts

@@ -7,46 +7,60 @@ export interface AgentTelemetryPayload {
     task: string;
     model: string;
     model_provider: string;
-    planner_llm: string | null;
     max_steps: number;
     max_actions_per_step: number;
-    use_vision: boolean;
-    use_validation: boolean;
+    use_vision: boolean | 'auto';
     version: string;
     source: string;
     cdp_url: string | null;
+    agent_type: string | null;
     action_errors: BaseSequence;
     action_history: Array<Array<Record<string, unknown>> | null> | undefined;
     urls_visited: BaseSequence;
     steps: number;
     total_input_tokens: number;
+    total_output_tokens: number;
+    prompt_cached_tokens: number;
+    total_tokens: number;
     total_duration_seconds: number;
     success: boolean | null;
     final_result_response: string | null;
     error_message: string | null;
+    judge_verdict?: boolean | null;
+    judge_reasoning?: string | null;
+    judge_failure_reason?: string | null;
+    judge_reached_captcha?: boolean | null;
+    judge_impossible_task?: boolean | null;
 }
 export declare class AgentTelemetryEvent extends BaseTelemetryEvent implements AgentTelemetryPayload {
     name: string;
     task: string;
     model: string;
     model_provider: string;
-    planner_llm: string | null;
     max_steps: number;
     max_actions_per_step: number;
-    use_vision: boolean;
-    use_validation: boolean;
+    use_vision: boolean | 'auto';
     version: string;
     source: string;
     cdp_url: string | null;
+    agent_type: string | null;
     action_errors: BaseSequence;
     action_history: Array<Array<Record<string, unknown>> | null> | undefined;
     urls_visited: BaseSequence;
     steps: number;
     total_input_tokens: number;
+    total_output_tokens: number;
+    prompt_cached_tokens: number;
+    total_tokens: number;
     total_duration_seconds: number;
     success: boolean | null;
     final_result_response: string | null;
     error_message: string | null;
+    judge_verdict: boolean | null;
+    judge_reasoning: string | null;
+    judge_failure_reason: string | null;
+    judge_reached_captcha: boolean | null;
+    judge_impossible_task: boolean | null;
     constructor(payload: AgentTelemetryPayload);
 }
 export interface MCPClientTelemetryPayload {

package/dist/telemetry/views.js

@@ -1,7 +1,11 @@
+import { is_running_in_docker } from '../config.js';
 export class BaseTelemetryEvent {
     properties() {
         const entries = Object.entries(this).filter(([key]) => key !== 'name');
-        return Object.fromEntries(entries);
+        return {
+            ...Object.fromEntries(entries),
+            is_docker: is_running_in_docker(),
+        };
     }
 }
 export class AgentTelemetryEvent extends BaseTelemetryEvent {
@@ -9,45 +13,59 @@ export class AgentTelemetryEvent extends BaseTelemetryEvent {
     task;
     model;
     model_provider;
-    planner_llm;
     max_steps;
     max_actions_per_step;
     use_vision;
-    use_validation;
     version;
     source;
     cdp_url;
+    agent_type;
     action_errors;
     action_history;
     urls_visited;
     steps;
     total_input_tokens;
+    total_output_tokens;
+    prompt_cached_tokens;
+    total_tokens;
     total_duration_seconds;
     success;
     final_result_response;
     error_message;
+    judge_verdict;
+    judge_reasoning;
+    judge_failure_reason;
+    judge_reached_captcha;
+    judge_impossible_task;
     constructor(payload) {
         super();
         this.task = payload.task;
         this.model = payload.model;
         this.model_provider = payload.model_provider;
-        this.planner_llm = payload.planner_llm;
         this.max_steps = payload.max_steps;
         this.max_actions_per_step = payload.max_actions_per_step;
         this.use_vision = payload.use_vision;
-        this.use_validation = payload.use_validation;
         this.version = payload.version;
         this.source = payload.source;
         this.cdp_url = payload.cdp_url;
+        this.agent_type = payload.agent_type;
         this.action_errors = payload.action_errors;
         this.action_history = payload.action_history;
         this.urls_visited = payload.urls_visited;
         this.steps = payload.steps;
         this.total_input_tokens = payload.total_input_tokens;
+        this.total_output_tokens = payload.total_output_tokens;
+        this.prompt_cached_tokens = payload.prompt_cached_tokens;
+        this.total_tokens = payload.total_tokens;
         this.total_duration_seconds = payload.total_duration_seconds;
         this.success = payload.success;
         this.final_result_response = payload.final_result_response;
         this.error_message = payload.error_message;
+        this.judge_verdict = payload.judge_verdict ?? null;
+        this.judge_reasoning = payload.judge_reasoning ?? null;
+        this.judge_failure_reason = payload.judge_failure_reason ?? null;
+        this.judge_reached_captcha = payload.judge_reached_captcha ?? null;
+        this.judge_impossible_task = payload.judge_impossible_task ?? null;
     }
 }
 export class MCPClientTelemetryEvent extends BaseTelemetryEvent {

package/dist/tokens/custom-pricing.d.ts

@@ -0,0 +1,2 @@
+import type { ModelPricing } from './views.js';
+export declare const CUSTOM_MODEL_PRICING: Record<string, Partial<ModelPricing> & Record<string, number | null | string>>;

package/dist/tokens/custom-pricing.js

@@ -0,0 +1,22 @@
+export const CUSTOM_MODEL_PRICING = {
+    'bu-1-0': {
+        input_cost_per_token: 0.2 / 1_000_000,
+        output_cost_per_token: 2.0 / 1_000_000,
+        cache_read_input_token_cost: 0.02 / 1_000_000,
+        cache_creation_input_token_cost: null,
+        max_tokens: null,
+        max_input_tokens: null,
+        max_output_tokens: null,
+    },
+    'bu-2-0': {
+        input_cost_per_token: 0.6 / 1_000_000,
+        output_cost_per_token: 3.5 / 1_000_000,
+        cache_read_input_token_cost: 0.06 / 1_000_000,
+        cache_creation_input_token_cost: null,
+        max_tokens: null,
+        max_input_tokens: null,
+        max_output_tokens: null,
+    },
+};
+CUSTOM_MODEL_PRICING['bu-latest'] = CUSTOM_MODEL_PRICING['bu-1-0'];
+CUSTOM_MODEL_PRICING.smart = CUSTOM_MODEL_PRICING['bu-1-0'];

package/dist/tokens/index.d.ts

@@ -1,2 +1,4 @@
 export * from './service.js';
 export * from './views.js';
+export * from './custom-pricing.js';
+export * from './mappings.js';

package/dist/tokens/index.js

@@ -1,2 +1,4 @@
 export * from './service.js';
 export * from './views.js';
+export * from './custom-pricing.js';
+export * from './mappings.js';

package/dist/tokens/mappings.d.ts

@@ -0,0 +1 @@
+export declare const MODEL_TO_LITELLM: Record<string, string>;

package/dist/tokens/mappings.js

@@ -0,0 +1,3 @@
+export const MODEL_TO_LITELLM = {
+    'gemini-flash-latest': 'gemini/gemini-flash-latest',
+};

package/dist/tokens/service.js

@@ -4,6 +4,9 @@ import { encode } from 'gpt-tokenizer';
 import axios from 'axios';
 import { CONFIG } from '../config.js';
 import { createLogger } from '../logging-config.js';
+import { create_task_with_error_handling } from '../utils.js';
+import { CUSTOM_MODEL_PRICING } from './custom-pricing.js';
+import { MODEL_TO_LITELLM } from './mappings.js';
 const logger = createLogger('browser_use.tokens');
 const costLogger = createLogger('browser_use.tokens.cost');
 const PRICING_URL = 'https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json';
@@ -66,7 +69,7 @@ export class TokenCost {
             }
         }
         catch (error) {
-            logger.warning(`Failed to load token pricing cache: ${error.message}`);
+            logger.debug(`Failed to load token pricing cache: ${error.message}`);
         }
         await this.fetchAndCachePricing();
     }
@@ -125,7 +128,7 @@ export class TokenCost {
             await fs.promises.writeFile(path.join(this.cacheDir, fileName), JSON.stringify(cached, null, 2));
         }
         catch (error) {
-            logger.error(`Failed to fetch LiteLLM pricing: ${error.message}`);
+            logger.debug(`Failed to fetch LiteLLM pricing: ${error.message}`);
             this.pricingData = this.pricingData ?? {};
         }
     }
@@ -145,16 +148,18 @@ export class TokenCost {
         this.registeredLlms.add(llm);
         const original = llm.ainvoke.bind(llm);
         this.originalAinvoke.set(llm, original);
-        const self = this;
-        llm.ainvoke = async function (...args) {
+        llm.ainvoke = (async (...args) => {
             // @ts-ignore - Spread operator type compatibility
             const result = await original(...args);
             if (result?.usage) {
-                const usageEntry = self.addUsage(llm.model, result.usage);
-                self.logUsage(llm.model, usageEntry).catch(() => undefined);
+                const usageEntry = this.addUsage(llm.model, result.usage);
+                create_task_with_error_handling(this.logUsage(llm.model, usageEntry), {
+                    name: 'log_token_usage',
+                    suppress_exceptions: true,
+                });
             }
             return result;
-        };
+        });
         return llm;
     }
     async logUsage(model, entry) {
@@ -168,7 +173,7 @@ export class TokenCost {
         const completionSection = this.includeCost && cost && cost.completion_cost > 0
             ? `📤 ${ansi.green}${completionTokensFmt} ($${cost.completion_cost.toFixed(4)})${ansi.reset}`
             : `📤 ${ansi.green}${completionTokensFmt}${ansi.reset}`;
-        costLogger.info(`🧠 ${ansi.cyan}${model}${ansi.reset} | ${inputPart} | ${completionSection}`);
+        costLogger.debug(`🧠 ${ansi.cyan}${model}${ansi.reset} | ${inputPart} | ${completionSection}`);
     }
     buildInputDisplay(usage, cost) {
         const parts = [];
@@ -245,11 +250,25 @@ export class TokenCost {
         };
     }
     async getModelPricing(modelName) {
+        const customPricing = CUSTOM_MODEL_PRICING[modelName];
+        if (customPricing) {
+            return {
+                model: modelName,
+                input_cost_per_token: customPricing.input_cost_per_token ?? null,
+                output_cost_per_token: customPricing.output_cost_per_token ?? null,
+                cache_read_input_token_cost: customPricing.cache_read_input_token_cost ?? null,
+                cache_creation_input_token_cost: customPricing.cache_creation_input_token_cost ?? null,
+                max_tokens: customPricing.max_tokens ?? null,
+                max_input_tokens: customPricing.max_input_tokens ?? null,
+                max_output_tokens: customPricing.max_output_tokens ?? null,
+            };
+        }
         await this.ensurePricingLoaded();
         if (!this.pricingData) {
             return null;
         }
-        const pricing = this.pricingData[modelName];
+        const litellmModelName = MODEL_TO_LITELLM[modelName] ?? modelName;
+        const pricing = this.pricingData[litellmModelName];
         if (!pricing) {
             return null;
         }
@@ -368,9 +387,8 @@ export class TokenCost {
         const completionCostPart = this.includeCost && summary.total_completion_cost > 0
             ? ` ($${summary.total_completion_cost.toFixed(4)})`
             : '';
-        costLogger.info(`💲 ${ansi.bold}Total Usage Summary${ansi.reset}: ${ansi.blue}${totalTokens} tokens${ansi.reset}${totalCostPart} | ` +
+        costLogger.debug(`💲 ${ansi.bold}Total Usage Summary${ansi.reset}: ${ansi.blue}${totalTokens} tokens${ansi.reset}${totalCostPart} | ` +
             `⬅️ ${ansi.yellow}${promptTokens}${promptCostPart}${ansi.reset} | ➡️ ${ansi.green}${completionTokens}${completionCostPart}${ansi.reset}`);
-        costLogger.info(`📊 ${ansi.bold}Per-Model Usage Breakdown${ansi.reset}:`);
         for (const [model, stats] of Object.entries(summary.by_model)) {
             const totalFmt = this.formatTokens(stats.total_tokens);
             const promptFmt = this.formatTokens(stats.prompt_tokens);
@@ -379,7 +397,7 @@ export class TokenCost {
             const costPart = this.includeCost && stats.cost > 0
                 ? ` ($${stats.cost.toFixed(4)})`
                 : '';
-            costLogger.info(`  🤖 ${ansi.cyan}${model}${ansi.reset}: ${ansi.blue}${totalFmt} tokens${ansi.reset}${costPart} | ` +
+            costLogger.debug(`  🤖 ${ansi.cyan}${model}${ansi.reset}: ${ansi.blue}${totalFmt} tokens${ansi.reset}${costPart} | ` +
                 `⬅️ ${ansi.yellow}${promptFmt}${ansi.reset} | ➡️ ${ansi.green}${completionFmt}${ansi.reset} | ` +
                 `📞 ${stats.invocations} calls | 📈 ${avgFmt}/call`);
         }

package/dist/tools/extraction/index.d.ts

@@ -0,0 +1,2 @@
+export * from './schema-utils.js';
+export * from './views.js';

package/dist/tools/extraction/index.js

@@ -0,0 +1,2 @@
+export * from './schema-utils.js';
+export * from './views.js';

package/dist/tools/extraction/schema-utils.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare const findUnsupportedJsonSchemaKeyword: (schema: unknown) => string | null;
+export declare const schemaDictToZodSchema: (schema: unknown) => z.ZodTypeAny;
+export declare const resolveDefaultForSchema: (schema: unknown) => unknown;
+export declare const normalizeStructuredDataBySchema: (value: unknown, schema: unknown) => unknown;
+export declare const schema_dict_to_zod_schema: (schema: unknown) => z.ZodTypeAny;

package/dist/tools/extraction/schema-utils.js

@@ -0,0 +1,237 @@
+import { z } from 'zod';
+const UNSUPPORTED_KEYWORDS = new Set([
+    '$ref',
+    'allOf',
+    'anyOf',
+    'oneOf',
+    'not',
+    '$defs',
+    'definitions',
+    'if',
+    'then',
+    'else',
+    'dependentSchemas',
+    'dependentRequired',
+]);
+const PRIMITIVE_DEFAULTS = {
+    string: '',
+    number: 0.0,
+    integer: 0,
+    boolean: false,
+};
+const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const getTypeList = (schema) => {
+    const schemaType = schema.type;
+    if (Array.isArray(schemaType)) {
+        return schemaType.map((item) => String(item).toLowerCase());
+    }
+    if (typeof schemaType === 'string' && schemaType.trim().length > 0) {
+        return [schemaType.toLowerCase()];
+    }
+    return ['string'];
+};
+export const findUnsupportedJsonSchemaKeyword = (schema) => {
+    if (Array.isArray(schema)) {
+        for (const item of schema) {
+            const found = findUnsupportedJsonSchemaKeyword(item);
+            if (found) {
+                return found;
+            }
+        }
+        return null;
+    }
+    if (!isRecord(schema)) {
+        return null;
+    }
+    for (const [key, value] of Object.entries(schema)) {
+        if (UNSUPPORTED_KEYWORDS.has(key)) {
+            return key;
+        }
+        const found = findUnsupportedJsonSchemaKeyword(value);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+};
+const checkUnsupported = (schema) => {
+    const unsupported = findUnsupportedJsonSchemaKeyword(schema);
+    if (unsupported) {
+        throw new Error(`Unsupported JSON Schema keyword: ${unsupported}`);
+    }
+};
+const resolveType = (schema, name) => {
+    checkUnsupported(schema);
+    const typeList = getTypeList(schema);
+    if (Array.isArray(schema.enum)) {
+        return z.string();
+    }
+    if (typeList.includes('object')) {
+        const properties = isRecord(schema.properties)
+            ? schema.properties
+            : null;
+        const base = properties
+            ? buildObjectSchema(schema, name)
+            : z.record(z.string(), z.any());
+        return typeList.includes('null') || schema.nullable === true
+            ? base.nullable()
+            : base;
+    }
+    if (typeList.includes('array')) {
+        const items = isRecord(schema.items)
+            ? resolveType(schema.items, `${name}_item`)
+            : z.any();
+        const arraySchema = z.array(items);
+        return typeList.includes('null') || schema.nullable === true
+            ? arraySchema.nullable()
+            : arraySchema;
+    }
+    let primitive = z.string();
+    if (typeList.includes('integer')) {
+        primitive = z.number().int();
+    }
+    else if (typeList.includes('number')) {
+        primitive = z.number();
+    }
+    else if (typeList.includes('boolean')) {
+        primitive = z.boolean();
+    }
+    else if (typeList.includes('null')) {
+        primitive = z.null();
+    }
+    else if (typeList.includes('string')) {
+        primitive = z.string();
+    }
+    if (schema.nullable === true && !typeList.includes('null')) {
+        return primitive.nullable();
+    }
+    return primitive;
+};
+const applyOptionalDefaults = (propertySchema, propertyType) => {
+    if (Object.prototype.hasOwnProperty.call(propertySchema, 'default')) {
+        return propertyType.default(propertySchema.default);
+    }
+    const typeList = getTypeList(propertySchema);
+    const allowsNull = propertySchema.nullable === true || typeList.includes('null');
+    if (allowsNull) {
+        return propertyType.nullable().default(null);
+    }
+    if (Array.isArray(propertySchema.enum)) {
+        return propertyType.nullable().default(null);
+    }
+    if (typeList.includes('array')) {
+        return propertyType.default([]);
+    }
+    const primitiveType = typeList.find((item) => item in PRIMITIVE_DEFAULTS);
+    if (primitiveType) {
+        return propertyType.default(PRIMITIVE_DEFAULTS[primitiveType]);
+    }
+    return propertyType.nullable().default(null);
+};
+const buildObjectSchema = (schema, name) => {
+    checkUnsupported(schema);
+    const properties = isRecord(schema.properties)
+        ? schema.properties
+        : {};
+    const required = new Set(Array.isArray(schema.required)
+        ? schema.required
+            .map((item) => String(item))
+            .filter((item) => item.length > 0)
+        : []);
+    const shape = {};
+    for (const [propertyName, propertySchema] of Object.entries(properties)) {
+        if (!isRecord(propertySchema)) {
+            shape[propertyName] = z.any();
+            continue;
+        }
+        const propertyType = resolveType(propertySchema, `${name}_${propertyName}`);
+        if (required.has(propertyName)) {
+            shape[propertyName] = propertyType;
+            continue;
+        }
+        shape[propertyName] = applyOptionalDefaults(propertySchema, propertyType);
+    }
+    return z.object(shape).strict();
+};
+export const schemaDictToZodSchema = (schema) => {
+    if (!isRecord(schema)) {
+        throw new Error('Top-level schema must be an object');
+    }
+    checkUnsupported(schema);
+    const typeList = getTypeList(schema);
+    if (!typeList.includes('object')) {
+        throw new Error('Top-level schema must have type "object"');
+    }
+    if (!isRecord(schema.properties) || !Object.keys(schema.properties).length) {
+        throw new Error('Top-level schema must have at least one property');
+    }
+    const modelName = typeof schema.title === 'string' && schema.title.trim().length > 0
+        ? schema.title
+        : 'DynamicExtractionModel';
+    return buildObjectSchema(schema, modelName);
+};
+export const resolveDefaultForSchema = (schema) => {
+    if (!isRecord(schema)) {
+        return null;
+    }
+    if (Object.prototype.hasOwnProperty.call(schema, 'default')) {
+        return schema.default;
+    }
+    const typeList = getTypeList(schema);
+    const allowsNull = schema.nullable === true || typeList.includes('null');
+    if (allowsNull) {
+        return null;
+    }
+    if (Array.isArray(schema.enum)) {
+        return null;
+    }
+    if (typeList.includes('array')) {
+        return [];
+    }
+    const primitiveType = typeList.find((item) => item in PRIMITIVE_DEFAULTS);
+    if (primitiveType) {
+        return PRIMITIVE_DEFAULTS[primitiveType];
+    }
+    return null;
+};
+export const normalizeStructuredDataBySchema = (value, schema) => {
+    if (!isRecord(schema)) {
+        return value;
+    }
+    const typeList = getTypeList(schema);
+    if (typeList.includes('object')) {
+        const properties = isRecord(schema.properties)
+            ? schema.properties
+            : {};
+        const required = new Set(Array.isArray(schema.required)
+            ? schema.required
+                .map((item) => String(item))
+                .filter((item) => item.length > 0)
+            : []);
+        const source = isRecord(value) ? value : {};
+        const normalized = {};
+        for (const [propertyName, propertySchema] of Object.entries(properties)) {
+            if (Object.prototype.hasOwnProperty.call(source, propertyName)) {
+                normalized[propertyName] = normalizeStructuredDataBySchema(source[propertyName], propertySchema);
+                continue;
+            }
+            if (required.has(propertyName)) {
+                continue;
+            }
+            normalized[propertyName] = resolveDefaultForSchema(propertySchema);
+        }
+        for (const [propertyName, propertyValue] of Object.entries(source)) {
+            if (!Object.prototype.hasOwnProperty.call(normalized, propertyName)) {
+                normalized[propertyName] = propertyValue;
+            }
+        }
+        return normalized;
+    }
+    if (typeList.includes('array') &&
+        Array.isArray(value) &&
+        isRecord(schema.items)) {
+        return value.map((item) => normalizeStructuredDataBySchema(item, schema.items));
+    }
+    return value;
+};
+export const schema_dict_to_zod_schema = schemaDictToZodSchema;

package/dist/tools/extraction/views.d.ts

@@ -0,0 +1,7 @@
+export interface ExtractionResult {
+    data: Record<string, unknown>;
+    schema_used: Record<string, unknown>;
+    is_partial?: boolean;
+    source_url?: string | null;
+    content_stats?: Record<string, unknown>;
+}

package/dist/tools/index.d.ts

@@ -0,0 +1,5 @@
+export * from './service.js';
+export * from './views.js';
+export * from './registry/index.js';
+export * from './extraction/index.js';
+export * from './utils.js';

package/dist/tools/index.js

@@ -0,0 +1,5 @@
+export * from './service.js';
+export * from './views.js';
+export * from './registry/index.js';
+export * from './extraction/index.js';
+export * from './utils.js';

package/dist/tools/registry/index.d.ts

@@ -0,0 +1,2 @@
+export * from './service.js';
+export * from './views.js';

package/dist/tools/registry/index.js

@@ -0,0 +1,2 @@
+export * from './service.js';
+export * from './views.js';

package/dist/tools/registry/service.d.ts

@@ -0,0 +1 @@
+export * from '../../controller/registry/service.js';

package/dist/tools/registry/service.js

@@ -0,0 +1 @@
+export * from '../../controller/registry/service.js';

package/dist/tools/registry/views.d.ts

@@ -0,0 +1 @@
+export * from '../../controller/registry/views.js';

package/dist/tools/registry/views.js

@@ -0,0 +1 @@
+export * from '../../controller/registry/views.js';

package/dist/tools/service.d.ts

@@ -0,0 +1,2 @@
+export { Controller as Tools } from '../controller/service.js';
+export type { ControllerOptions as ToolsOptions, ActParams as ToolsActParams, } from '../controller/service.js';

package/dist/tools/service.js

@@ -0,0 +1 @@
+export { Controller as Tools } from '../controller/service.js';

package/dist/tools/utils.d.ts

@@ -0,0 +1,2 @@
+import { DOMElementNode } from '../dom/views.js';
+export declare const getClickDescription: (node: DOMElementNode) => string;

package/dist/tools/utils.js

@@ -0,0 +1,57 @@
+import { DOMElementNode } from '../dom/views.js';
+const normalizeBoolLike = (value) => {
+    const normalized = String(value ?? '')
+        .trim()
+        .toLowerCase();
+    return normalized === 'true' || normalized === 'checked' || normalized === '';
+};
+const summarizeText = (text, maxLength = 30) => {
+    const compact = text.replace(/\s+/g, ' ').trim();
+    if (!compact) {
+        return '';
+    }
+    return compact.length > maxLength
+        ? `${compact.slice(0, maxLength)}...`
+        : compact;
+};
+export const getClickDescription = (node) => {
+    const parts = [node.tag_name];
+    const inputType = node.attributes.type;
+    if (node.tag_name === 'input' && inputType) {
+        parts.push(`type=${inputType}`);
+        if (inputType === 'checkbox') {
+            const isChecked = normalizeBoolLike(node.attributes.checked);
+            parts.push(`checkbox-state=${isChecked ? 'checked' : 'unchecked'}`);
+        }
+    }
+    const role = node.attributes.role;
+    if (role) {
+        parts.push(`role=${role}`);
+        if (role === 'checkbox') {
+            const isChecked = normalizeBoolLike(node.attributes['aria-checked']);
+            parts.push(`checkbox-state=${isChecked ? 'checked' : 'unchecked'}`);
+        }
+    }
+    if (['label', 'span', 'div'].includes(node.tag_name) &&
+        !parts.some((part) => part.startsWith('type='))) {
+        const hiddenCheckboxChild = node.children.find((child) => child instanceof DOMElementNode &&
+            child.tag_name === 'input' &&
+            child.attributes.type === 'checkbox' &&
+            !child.is_visible);
+        if (hiddenCheckboxChild) {
+            const isChecked = normalizeBoolLike(hiddenCheckboxChild.attributes.checked);
+            parts.push(`checkbox-state=${isChecked ? 'checked' : 'unchecked'}`);
+        }
+    }
+    const text = summarizeText(node.get_all_text_till_next_clickable_element());
+    if (text) {
+        parts.push(`"${text}"`);
+    }
+    for (const attribute of ['id', 'name', 'aria-label']) {
+        const value = node.attributes[attribute];
+        if (value && value.trim().length > 0) {
+            parts.push(`${attribute}=${value.slice(0, 20)}`);
+        }
+    }
+    return parts.join(' ');
+};

package/dist/tools/views.d.ts

@@ -0,0 +1 @@
+export * from '../controller/views.js';

package/dist/tools/views.js

@@ -0,0 +1 @@
+export * from '../controller/views.js';