anchorbrowser/resources/agent.js

The official TypeScript library for the Anchorbrowser API

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Agent = void 0;
const ws_1 = require("ws");
const resource_1 = require("../core/resource.js");
const browser_1 = require("../lib/browser.js");
class Agent extends resource_1.APIResource {
    /**
     * Execute an AI agent task in a browser session
     * @param prompt - The task prompt for the AI agent
     * @param options - Session and task configuration options
     * @returns The result of the task execution
     * @throws Error if browser setup fails or task execution fails
     */
    async task(prompt, { sessionOptions, taskOptions, sessionId, } = {}) {
        const setup = await this.setupBrowser(sessionOptions, sessionId);
        let webSocket = null;
        try {
            // Navigate to URL if provided
            if (taskOptions?.url && setup.page) {
                await setup.page.goto(taskOptions.url);
            }
            // Setup WebSocket for step notifications
            if (taskOptions?.onAgentStep) {
                webSocket = this.setupWebSocket(setup.session.data?.id, taskOptions.onAgentStep);
            }
            // Execute the task
            const taskResult = await this.executeTask(setup.ai, prompt, taskOptions);
            return taskResult;
        }
        finally {
            // Cleanup resources
            this.cleanupWebSocket(webSocket);
            await setup.browser.close();
        }
    }
    /**
     * Create a browser task that returns control to the caller
     * @param prompt - The task prompt for the AI agent
     * @param options - Session and task configuration options
     * @returns Object containing session ID, task promise, and browser instance
     * @throws Error if browser setup fails
     */
    async browserTask(prompt, { sessionOptions, taskOptions, } = {}) {
        const setup = await this.setupBrowser(sessionOptions);
        try {
            // Navigate to URL if provided
            if (taskOptions?.url && setup.page) {
                await setup.page.goto(taskOptions.url);
            }
            // Create task promise without executing it
            const taskPayload = this.createTaskPayload(prompt, taskOptions);
            const taskResultPromise = setup.ai?.evaluate(taskPayload);
            if (!taskResultPromise) {
                throw new Error('Failed to create task: AI worker not available');
            }
            return {
                sessionId: setup.session.data?.id,
                taskResultPromise,
                playwrightBrowser: setup.browser,
            };
        }
        catch (error) {
            console.error('Error in browserTask:', error);
            throw error;
        }
    }
    /**
     * Set up browser and session
     */
    async setupBrowser(sessionOptions, sessionId) {
        const session = sessionId ?
            {
                data: {
                    id: sessionId,
                    cdp_url: (0, browser_1.getCdpUrl)(this._client.baseURL, sessionId, this._client.apiKey),
                    live_view_url: this._client.baseURL,
                },
            }
            : await this._client.sessions.create(sessionOptions);
        if (!session.data?.id) {
            throw new Error('Failed to create session: No session ID returned');
        }
        const browser = await (0, browser_1.getPlaywrightChromiumFromCdpUrl)(this._client.baseURL, session.data.id, this._client.apiKey);
        const context = browser.contexts()[0];
        if (!context) {
            await browser.close();
            throw new Error('No browser context available');
        }
        const ai = (0, browser_1.getAiServiceWorker)(context);
        const page = context.pages()[0];
        if (!ai) {
            await browser.close();
            throw new Error('AI service worker not available');
        }
        return { session, browser, context, page, ai };
    }
    /**
     * Set up WebSocket for agent step notifications
     */
    setupWebSocket(sessionId, onAgentStep) {
        if (!sessionId) {
            throw new Error('Session ID required for WebSocket connection');
        }
        const webSocket = new ws_1.WebSocket((0, browser_1.getAgentWsUrl)(this._client.baseURL, sessionId));
        webSocket.on('message', (data) => {
            try {
                const parsed = JSON.parse(data.toString());
                onAgentStep(parsed);
            }
            catch (error) {
                console.error('Failed to parse WebSocket message:', error);
            }
        });
        webSocket.on('error', (error) => {
            console.error('WebSocket error:', error);
        });
        return webSocket;
    }
    /**
     * Create task payload for AI execution
     */
    createTaskPayload(prompt, taskOptions) {
        if (!prompt || prompt.trim().length === 0) {
            throw new Error('Prompt cannot be empty');
        }
        return JSON.stringify({
            prompt,
            output_schema: taskOptions?.outputSchema,
            model: taskOptions?.model,
            provider: taskOptions?.provider,
        });
    }
    /**
     * Execute task on AI worker
     */
    async executeTask(ai, prompt, outputSchema) {
        const taskPayload = this.createTaskPayload(prompt, outputSchema);
        const result = await ai.evaluate(taskPayload);
        return result;
    }
    /**
     * Clean up WebSocket connection
     */
    cleanupWebSocket(webSocket) {
        if (webSocket) {
            try {
                webSocket.close();
                webSocket.terminate();
            }
            catch (error) {
                console.error('Error closing WebSocket:', error);
            }
        }
    }
}
exports.Agent = Agent;
//# sourceMappingURL=agent.js.map