@tabstack/sdk 1.0.5 → 2.1.0

package/dist/cjs/agent.js

@@ -1,211 +0,0 @@
-"use strict";
-/**
- * Agent client for Tabstack SDK
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Agent = void 0;
-const types_1 = require("./types");
-/**
- * Agent client for AI-powered web automation
- *
- * This class provides methods for executing complex web automation tasks using
- * natural language instructions. The automation runs in a browser and streams
- * real-time progress updates.
- */
-class Agent {
-    constructor(httpClient) {
-        this.httpClient = httpClient;
-    }
-    /**
-     * Execute AI-powered browser automation task with streaming updates
-     *
-     * Execute complex web automation tasks using natural language instructions. This method
-     * always streams responses using Server-Sent Events (SSE), providing real-time progress
-     * updates as the task executes. Perfect for web scraping, form filling, navigation,
-     * information gathering, and multi-step workflows.
-     *
-     * @param task - The task description in natural language. Example: "Find the top 3 trending repositories on GitHub and extract their names, descriptions, and star counts"
-     * @param options - Optional automation options
-     * @param options.url - Starting URL for the task. Optional but recommended for better context.
-     * @param options.data - JSON data to provide context for form filling or complex tasks. Example: { "language": "Python", "timeRange": "today" }
-     * @param options.guardrails - Safety constraints for execution. Example: "browse and extract data only, don't star or fork repositories"
-     * @param options.maxIterations - Maximum task iterations. Default: 50, Min: 1, Max: 100
-     * @param options.maxValidationAttempts - Maximum validation attempts. Default: 3, Min: 1, Max: 10
-     *
-     * @yields AutomateEvent objects representing different stages of task execution
-     *
-     * @throws {BadRequestError} When task is missing, URL format is invalid, or maxIterations is out of range
-     * @throws {UnauthorizedError} When API key is invalid or missing
-     * @throws {ServerError} When automation server call fails
-     * @throws {ServiceUnavailableError} When automate service is not available
-     *
-     * Event Types:
-     * - **Task Events**: `start`, `task:setup`, `task:started`, `task:completed`, `task:aborted`, `task:validated`, `task:validation_error`
-     * - **Agent Events**: `agent:processing`, `agent:status`, `agent:step`, `agent:action`, `agent:reasoned`, `agent:extracted`, `agent:waiting`
-     * - **Browser Events**: `browser:navigated`, `browser:action_started`, `browser:action_completed`, `browser:screenshot_captured`
-     * - **System Events**: `system:debug_compression`, `system:debug_message`
-     * - **Stream Control**: `complete`, `done`, `error`
-     *
-     * @example
-     * Extract GitHub trending repositories:
-     * ```typescript
-     * for await (const event of tabs.agent.automate(
-     *   'Find the top 3 trending repositories and extract their names, descriptions, and star counts',
-     *   {
-     *     url: 'https://github.com/trending',
-     *     guardrails: 'browse and extract only, don\'t interact with repositories'
-     *   }
-     * )) {
-     *   console.log(`Event: ${event.type}`);
-     *
-     *   if (event.type === 'task:completed') {
-     *     console.log('Result:', event.data.get('finalAnswer'));
-     *   } else if (event.type === 'agent:extracted') {
-     *     console.log('Extracted data:', event.data.get('extractedData'));
-     *   } else if (event.type === 'browser:navigated') {
-     *     console.log('Navigated to:', event.data.get('url'));
-     *   }
-     * }
-     * ```
-     *
-     * @example
-     * Scrape product information:
-     * ```typescript
-     * for await (const event of tabs.agent.automate(
-     *   'Find the product name, price, and availability status',
-     *   {
-     *     url: 'https://example-store.com/product/wireless-headphones',
-     *     guardrails: 'extract product details only, don\'t add to cart or checkout',
-     *     maxIterations: 20
-     *   }
-     * )) {
-     *   if (event.type === 'agent:processing') {
-     *     console.log('Agent thinking:', event.data.get('operation'));
-     *   } else if (event.type === 'task:completed') {
-     *     const result = event.data.get('finalAnswer');
-     *     console.log('Product info:', result);
-     *   }
-     * }
-     * ```
-     *
-     * @example
-     * Fill out contact form:
-     * ```typescript
-     * for await (const event of tabs.agent.automate(
-     *   'Submit the contact form with my information',
-     *   {
-     *     url: 'https://company.com/contact',
-     *     data: {
-     *       name: 'Alex Johnson',
-     *       email: 'alex@example.com',
-     *       message: 'Interested in learning more about your enterprise plan'
-     *     },
-     *     maxIterations: 30,
-     *     maxValidationAttempts: 5
-     *   }
-     * )) {
-     *   if (event.type === 'agent:action') {
-     *     console.log('Action:', event.data.get('action'), event.data.get('value'));
-     *   } else if (event.type === 'task:completed') {
-     *     console.log('Form submitted successfully!');
-     *   }
-     * }
-     * ```
-     *
-     * @example
-     * Handle all event types:
-     * ```typescript
-     * for await (const event of tabs.agent.automate(
-     *   'Research TypeScript frameworks and compare them',
-     *   { url: 'https://www.npmjs.com' }
-     * )) {
-     *   switch (event.type) {
-     *     case 'start':
-     *       console.log('Task started');
-     *       break;
-     *     case 'agent:status':
-     *       console.log('Status:', event.data.get('message'));
-     *       break;
-     *     case 'agent:step':
-     *       const iteration = event.data.get('currentIteration');
-     *       console.log(`Processing step ${iteration}...`);
-     *       break;
-     *     case 'browser:navigated':
-     *       console.log('Page:', event.data.get('title'));
-     *       break;
-     *     case 'task:completed':
-     *       console.log('Final result:', event.data.get('finalAnswer'));
-     *       break;
-     *     case 'error':
-     *       console.error('Error occurred:', event.data.getRaw());
-     *       break;
-     *   }
-     * }
-     * ```
-     */
-    async *automate(task, options) {
-        const requestData = {
-            task,
-            maxIterations: options?.maxIterations ?? 50,
-            maxValidationAttempts: options?.maxValidationAttempts ?? 3,
-        };
-        if (options?.url)
-            requestData.url = options.url;
-        if (options?.data)
-            requestData.data = options.data;
-        if (options?.guardrails)
-            requestData.guardrails = options.guardrails;
-        // Stream the response and parse SSE events
-        let currentEventType = null;
-        let currentEventData = '';
-        for await (const line of this.httpClient.postStream('v1/automate', requestData)) {
-            // SSE format: "event: <type>" or "data: <json>"
-            if (line.startsWith('event:')) {
-                // If we have a pending event, yield it before starting a new one
-                if (currentEventType) {
-                    yield this.parseEvent(currentEventType, currentEventData);
-                    currentEventData = '';
-                }
-                // Extract event type
-                currentEventType = line.slice(6).trim();
-            }
-            else if (line.startsWith('data:')) {
-                // Accumulate event data (can be multiline)
-                const dataLine = line.slice(5).trim();
-                if (currentEventData) {
-                    currentEventData += '\n' + dataLine;
-                }
-                else {
-                    currentEventData = dataLine;
-                }
-            }
-            else if (line === '') {
-                // Empty line marks the end of an event
-                if (currentEventType) {
-                    yield this.parseEvent(currentEventType, currentEventData);
-                    currentEventType = null;
-                    currentEventData = '';
-                }
-            }
-        }
-        // Yield any remaining event
-        if (currentEventType) {
-            yield this.parseEvent(currentEventType, currentEventData);
-        }
-    }
-    /**
-     * Parse SSE event data
-     */
-    parseEvent(eventType, eventData) {
-        try {
-            const data = JSON.parse(eventData);
-            return types_1.AutomateEvent.fromJSON(eventType, data);
-        }
-        catch {
-            // If data is not valid JSON, return it as-is
-            return types_1.AutomateEvent.fromJSON(eventType, { raw: eventData });
-        }
-    }
-}
-exports.Agent = Agent;
-//# sourceMappingURL=agent.js.map

package/dist/cjs/agent.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent.js","sourceRoot":"","sources":["../../src/agent.ts"],"names":[],"mappings":"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"}

package/dist/cjs/agent.test.d.ts

@@ -1,5 +0,0 @@
-/**
- * Tests for Agent
- */
-export {};
-//# sourceMappingURL=agent.test.d.ts.map

package/dist/cjs/agent.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent.test.d.ts","sourceRoot":"","sources":["../../src/agent.test.ts"],"names":[],"mappings":"AAAA;;GAEG"}

package/dist/cjs/agent.test.js

@@ -1,441 +0,0 @@
-"use strict";
-/**
- * Tests for Agent
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-// @ts-nocheck
-const agent_1 = require("./agent");
-const http_1 = require("./util/http");
-// Mock HTTPClient
-jest.mock('./util/http');
-describe('Agent', () => {
-    let agent;
-    let mockHttpClient;
-    beforeEach(() => {
-        mockHttpClient = new http_1.HTTPClient({ apiKey: 'test-key' });
-        agent = new agent_1.Agent(mockHttpClient);
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-    // Helper to create async generator from array
-    async function* streamLines(lines) {
-        for (const line of lines) {
-            yield line;
-        }
-    }
-    describe('automate', () => {
-        it('should execute task with minimal options', async () => {
-            const sseLines = [
-                'event: start',
-                'data: {"message":"Task started"}',
-                '',
-                'event: task:completed',
-                'data: {"finalAnswer":"Result"}',
-                '',
-            ];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Test task')) {
-                events.push(event);
-            }
-            expect(mockHttpClient.postStream).toHaveBeenCalledWith('v1/automate', {
-                task: 'Test task',
-                maxIterations: 50,
-                maxValidationAttempts: 3,
-            });
-            expect(events).toHaveLength(2);
-            expect(events[0].type).toBe('start');
-            expect(events[1].type).toBe('task:completed');
-        });
-        it('should execute task with url option', async () => {
-            const sseLines = ['event: start', 'data: {}', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Test task', {
-                url: 'https://example.com',
-            })) {
-                events.push(event);
-            }
-            expect(mockHttpClient.postStream).toHaveBeenCalledWith('v1/automate', {
-                task: 'Test task',
-                url: 'https://example.com',
-                maxIterations: 50,
-                maxValidationAttempts: 3,
-            });
-        });
-        it('should execute task with data option', async () => {
-            const sseLines = ['event: start', 'data: {}', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const data = { name: 'John', email: 'john@example.com' };
-            const events = [];
-            for await (const event of agent.automate('Fill form', { data })) {
-                events.push(event);
-            }
-            expect(mockHttpClient.postStream).toHaveBeenCalledWith('v1/automate', {
-                task: 'Fill form',
-                data,
-                maxIterations: 50,
-                maxValidationAttempts: 3,
-            });
-        });
-        it('should execute task with guardrails option', async () => {
-            const sseLines = ['event: start', 'data: {}', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Browse site', {
-                guardrails: 'read only, no modifications',
-            })) {
-                events.push(event);
-            }
-            expect(mockHttpClient.postStream).toHaveBeenCalledWith('v1/automate', {
-                task: 'Browse site',
-                guardrails: 'read only, no modifications',
-                maxIterations: 50,
-                maxValidationAttempts: 3,
-            });
-        });
-        it('should execute task with custom maxIterations', async () => {
-            const sseLines = ['event: start', 'data: {}', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Test task', { maxIterations: 100 })) {
-                events.push(event);
-            }
-            expect(mockHttpClient.postStream).toHaveBeenCalledWith('v1/automate', {
-                task: 'Test task',
-                maxIterations: 100,
-                maxValidationAttempts: 3,
-            });
-        });
-        it('should execute task with custom maxValidationAttempts', async () => {
-            const sseLines = ['event: start', 'data: {}', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Test task', { maxValidationAttempts: 5 })) {
-                events.push(event);
-            }
-            expect(mockHttpClient.postStream).toHaveBeenCalledWith('v1/automate', {
-                task: 'Test task',
-                maxIterations: 50,
-                maxValidationAttempts: 5,
-            });
-        });
-        it('should execute task with all options', async () => {
-            const sseLines = ['event: start', 'data: {}', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Complete task', {
-                url: 'https://example.com',
-                data: { key: 'value' },
-                guardrails: 'safe mode',
-                maxIterations: 75,
-                maxValidationAttempts: 4,
-            })) {
-                events.push(event);
-            }
-            expect(mockHttpClient.postStream).toHaveBeenCalledWith('v1/automate', {
-                task: 'Complete task',
-                url: 'https://example.com',
-                data: { key: 'value' },
-                guardrails: 'safe mode',
-                maxIterations: 75,
-                maxValidationAttempts: 4,
-            });
-        });
-    });
-    describe('SSE parsing', () => {
-        it('should parse single event', async () => {
-            const sseLines = ['event: start', 'data: {"message":"Started"}', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(1);
-            expect(events[0].type).toBe('start');
-            expect(events[0].data.get('message')).toBe('Started');
-        });
-        it('should parse multiple events', async () => {
-            const sseLines = [
-                'event: start',
-                'data: {"step":1}',
-                '',
-                'event: agent:processing',
-                'data: {"operation":"analyze"}',
-                '',
-                'event: task:completed',
-                'data: {"finalAnswer":"Done"}',
-                '',
-            ];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(3);
-            expect(events[0].type).toBe('start');
-            expect(events[1].type).toBe('agent:processing');
-            expect(events[2].type).toBe('task:completed');
-        });
-        it('should handle multiline data', async () => {
-            const sseLines = [
-                'event: agent:extracted',
-                'data: {"items":[',
-                'data: {"name":"Item1"},',
-                'data: {"name":"Item2"}',
-                'data: ]}',
-                '',
-            ];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(1);
-            expect(events[0].type).toBe('agent:extracted');
-            // Data should be concatenated with newlines
-            const data = events[0].data.getRaw();
-            expect(data).toBeDefined();
-        });
-        it('should handle events without empty line separator', async () => {
-            const sseLines = ['event: start', 'data: {"message":"Started"}'];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            // Should still yield the last event even without trailing empty line
-            expect(events).toHaveLength(1);
-            expect(events[0].type).toBe('start');
-        });
-        it('should handle events with extra whitespace', async () => {
-            const sseLines = ['event:  start  ', 'data:  {"message":"Test"}  ', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(1);
-            expect(events[0].type).toBe('start');
-            expect(events[0].data.get('message')).toBe('Test');
-        });
-        it('should skip empty lines between data', async () => {
-            const sseLines = ['event: start', '', 'data: {"message":"Test"}', '', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(1);
-            expect(events[0].type).toBe('start');
-        });
-        it('should handle different event types', async () => {
-            const eventTypes = [
-                'start',
-                'task:setup',
-                'task:started',
-                'task:completed',
-                'agent:processing',
-                'agent:status',
-                'agent:step',
-                'agent:action',
-                'browser:navigated',
-                'complete',
-                'done',
-                'error',
-            ];
-            const sseLines = [];
-            eventTypes.forEach((type) => {
-                sseLines.push(`event: ${type}`);
-                sseLines.push('data: {}');
-                sseLines.push('');
-            });
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(eventTypes.length);
-            events.forEach((event, index) => {
-                expect(event.type).toBe(eventTypes[index]);
-            });
-        });
-    });
-    describe('parseEvent', () => {
-        it('should parse valid JSON data', async () => {
-            const sseLines = [
-                'event: agent:extracted',
-                'data: {"extractedData":{"title":"Test","count":42}}',
-                '',
-            ];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events[0].data.get('extractedData')).toEqual({ title: 'Test', count: 42 });
-        });
-        it('should handle invalid JSON gracefully', async () => {
-            const sseLines = ['event: error', 'data: Invalid JSON {{{', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events[0].type).toBe('error');
-            expect(events[0].data.get('raw')).toBe('Invalid JSON {{{');
-        });
-        it('should handle empty data', async () => {
-            const sseLines = ['event: start', 'data: ', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(1);
-            expect(events[0].type).toBe('start');
-        });
-        it('should handle complex nested JSON', async () => {
-            const complexData = {
-                result: {
-                    items: [
-                        { id: 1, name: 'Item 1', tags: ['a', 'b'] },
-                        { id: 2, name: 'Item 2', tags: ['c', 'd'] },
-                    ],
-                    metadata: { count: 2, timestamp: 1234567890 },
-                },
-            };
-            const sseLines = ['event: agent:extracted', `data: ${JSON.stringify(complexData)}`, ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events[0].data.get('result')).toEqual(complexData.result);
-        });
-    });
-    describe('Event data access', () => {
-        it('should access event data properties', async () => {
-            const sseLines = [
-                'event: browser:navigated',
-                'data: {"url":"https://example.com","title":"Example"}',
-                '',
-            ];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events[0].data.get('url')).toBe('https://example.com');
-            expect(events[0].data.get('title')).toBe('Example');
-        });
-        it('should handle missing properties', async () => {
-            const sseLines = ['event: start', 'data: {"message":"Test"}', ''];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events[0].data.get('nonexistent')).toBeUndefined();
-            expect(events[0].data.get('nonexistent', 'default')).toBe('default');
-        });
-        it('should access raw event data', async () => {
-            const sseLines = [
-                'event: agent:step',
-                'data: {"currentIteration":5,"totalIterations":50}',
-                '',
-            ];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            const raw = events[0].data.getRaw();
-            expect(raw.currentIteration).toBe(5);
-            expect(raw.totalIterations).toBe(50);
-        });
-    });
-    describe('Integration scenarios', () => {
-        it('should stream complete automation workflow', async () => {
-            const sseLines = [
-                'event: start',
-                'data: {"message":"Starting automation"}',
-                '',
-                'event: task:setup',
-                'data: {"task":"Extract data"}',
-                '',
-                'event: browser:navigated',
-                'data: {"url":"https://example.com"}',
-                '',
-                'event: agent:processing',
-                'data: {"operation":"analyze"}',
-                '',
-                'event: agent:extracted',
-                'data: {"extractedData":{"items":[]}}',
-                '',
-                'event: task:completed',
-                'data: {"finalAnswer":"Success"}',
-                '',
-                'event: done',
-                'data: {}',
-                '',
-            ];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Extract data', {
-                url: 'https://example.com',
-            })) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(7);
-            expect(events[0]?.type).toBe('start');
-            expect(events[events.length - 2]?.type).toBe('task:completed');
-            expect(events[events.length - 1]?.type).toBe('done');
-        });
-        it('should handle error events', async () => {
-            const sseLines = [
-                'event: start',
-                'data: {"message":"Started"}',
-                '',
-                'event: error',
-                'data: {"error":"Task failed","reason":"Network error"}',
-                '',
-            ];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task')) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(2);
-            expect(events[1]?.type).toBe('error');
-            expect(events[1]?.data.get('error')).toBe('Task failed');
-        });
-        it('should handle task abortion', async () => {
-            const sseLines = [
-                'event: start',
-                'data: {}',
-                '',
-                'event: task:aborted',
-                'data: {"reason":"Max iterations exceeded"}',
-                '',
-            ];
-            mockHttpClient.postStream = jest.fn().mockReturnValue(streamLines(sseLines));
-            const events = [];
-            for await (const event of agent.automate('Task', { maxIterations: 10 })) {
-                events.push(event);
-            }
-            expect(events).toHaveLength(2);
-            expect(events[1]?.type).toBe('task:aborted');
-        });
-        it('should propagate HTTP client errors', async () => {
-            const error = new Error('Stream error');
-            mockHttpClient.postStream = jest.fn().mockImplementation(async function* () {
-                throw error;
-            });
-            const generator = agent.automate('Task');
-            await expect(generator.next()).rejects.toThrow('Stream error');
-        });
-    });
-});
-//# sourceMappingURL=agent.test.js.map