@tabstack/sdk 1.0.5 → 2.0.0

package/dist/types/agent.d.ts

@@ -1,156 +0,0 @@
-/**
- * Agent client for Tabstack SDK
- */
-import { HTTPClient } from './util/http';
-import { AutomateEvent } from './types';
-export interface AutomateOptions {
-    url?: string;
-    data?: Record<string, unknown>;
-    guardrails?: string;
-    maxIterations?: number;
-    maxValidationAttempts?: number;
-}
-/**
- * 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.
- */
-export declare class Agent {
-    private httpClient;
-    constructor(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;
-     *   }
-     * }
-     * ```
-     */
-    automate(task: string, options?: AutomateOptions): AsyncGenerator<AutomateEvent, void, undefined>;
-    /**
-     * Parse SSE event data
-     */
-    private parseEvent;
-}
-//# sourceMappingURL=agent.d.ts.map

package/dist/types/agent.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"agent.d.ts","sourceRoot":"","sources":["../../src/agent.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,aAAa,EAAE,MAAM,SAAS,CAAC;AAExC,MAAM,WAAW,eAAe;IAC9B,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;GAMG;AACH,qBAAa,KAAK;IACJ,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8HG;IACI,QAAQ,CACb,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,eAAe,GACxB,cAAc,CAAC,aAAa,EAAE,IAAI,EAAE,SAAS,CAAC;IAkDjD;;OAEG;IACH,OAAO,CAAC,UAAU;CASnB"}

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

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

package/dist/types/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/types/client.d.ts

@@ -1,58 +0,0 @@
-/**
- * Main client for Tabstack SDK
- */
-import { Extract } from './extract';
-import { Generate } from './generate';
-import { Agent } from './agent';
-export interface TabstackOptions {
-    apiKey: string;
-    baseURL?: string;
-}
-/**
- * Tabstack client for web content extraction, generation, and automation
- *
- * This is the main entry point for the Tabstack SDK. Initialize it with your
- * API key to access the extract, generate, and automate operators.
- *
- * @example
- * ```typescript
- * import { Tabstack } from '@tabstack/sdk';
- *
- * const tabs = new Tabstack({
- *   apiKey: process.env.TABSTACK_API_KEY!
- * });
- *
- * const result = await tabs.extract.markdown('https://example.com');
- * console.log(result.content);
- * ```
- */
-export declare class Tabstack {
-    private httpClient;
-    /**
-     * Extract operator for converting and extracting web content
-     */
-    readonly extract: Extract;
-    /**
-     * Generate operator for AI-powered content transformation
-     */
-    readonly generate: Generate;
-    /**
-     * Agent client for AI-powered browser automation tasks
-     */
-    readonly agent: Agent;
-    /**
-     * Initialize Tabstack client
-     *
-     * @param options - Configuration options
-     * @throws Error if apiKey is empty or not provided
-     *
-     * @example
-     * ```typescript
-     * const tabs = new Tabstack({
-     *   apiKey: 'your-api-key-here'
-     * });
-     * ```
-     */
-    constructor(options: TabstackOptions);
-}
-//# sourceMappingURL=client.d.ts.map

package/dist/types/client.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/client.ts"],"names":[],"mappings":"AAAA;;GAEG;AAGH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAEhC,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,QAAQ;IACnB,OAAO,CAAC,UAAU,CAAa;IAE/B;;OAEG;IACH,SAAgB,OAAO,EAAE,OAAO,CAAC;IAEjC;;OAEG;IACH,SAAgB,QAAQ,EAAE,QAAQ,CAAC;IAEnC;;OAEG;IACH,SAAgB,KAAK,EAAE,KAAK,CAAC;IAE7B;;;;;;;;;;;;OAYG;gBACS,OAAO,EAAE,eAAe;CAerC"}

package/dist/types/client.test.d.ts

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

package/dist/types/client.test.d.ts.map

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

package/dist/types/exceptions.d.ts

@@ -1,57 +0,0 @@
-/**
- * Custom exceptions for Tabstack SDK
- */
-/**
- * Base error class for all Tabstack errors
- */
-export declare class TabstackError extends Error {
-    statusCode?: number | undefined;
-    constructor(message: string, statusCode?: number | undefined);
-}
-/**
- * Error for 400 Bad Request responses
- *
- * Raised when the request is malformed or missing required fields.
- */
-export declare class BadRequestError extends TabstackError {
-    constructor(message: string);
-}
-/**
- * Error for 401 Unauthorized responses
- *
- * Raised when the API key is invalid or missing.
- */
-export declare class UnauthorizedError extends TabstackError {
-    constructor(message?: string);
-}
-/**
- * Error for 422 Unprocessable Entity responses related to URLs
- *
- * Raised when the provided URL is invalid or inaccessible.
- */
-export declare class InvalidURLError extends TabstackError {
-    constructor(message?: string);
-}
-/**
- * Error for 500 Internal Server Error responses
- *
- * Raised when the server encounters an error processing the request.
- */
-export declare class ServerError extends TabstackError {
-    constructor(message?: string);
-}
-/**
- * Error for 503 Service Unavailable responses
- *
- * Raised when a service (e.g., automate) is not available or not configured.
- */
-export declare class ServiceUnavailableError extends TabstackError {
-    constructor(message?: string);
-}
-/**
- * Generic API error for unexpected status codes
- */
-export declare class APIError extends TabstackError {
-    constructor(message: string, statusCode: number);
-}
-//# sourceMappingURL=exceptions.d.ts.map

package/dist/types/exceptions.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"exceptions.d.ts","sourceRoot":"","sources":["../../src/exceptions.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;GAEG;AACH,qBAAa,aAAc,SAAQ,KAAK;IAG7B,UAAU,CAAC,EAAE,MAAM;gBAD1B,OAAO,EAAE,MAAM,EACR,UAAU,CAAC,EAAE,MAAM,YAAA;CAM7B;AAED;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,aAAa;gBACpC,OAAO,EAAE,MAAM;CAK5B;AAED;;;;GAIG;AACH,qBAAa,iBAAkB,SAAQ,aAAa;gBACtC,OAAO,GAAE,MAAoD;CAK1E;AAED;;;;GAIG;AACH,qBAAa,eAAgB,SAAQ,aAAa;gBACpC,OAAO,GAAE,MAAsC;CAK5D;AAED;;;;GAIG;AACH,qBAAa,WAAY,SAAQ,aAAa;gBAChC,OAAO,GAAE,MAAgC;CAKtD;AAED;;;;GAIG;AACH,qBAAa,uBAAwB,SAAQ,aAAa;gBAC5C,OAAO,GAAE,MAA8B;CAKpD;AAED;;GAEG;AACH,qBAAa,QAAS,SAAQ,aAAa;gBAC7B,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM;CAKhD"}

package/dist/types/exceptions.test.d.ts

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

package/dist/types/exceptions.test.d.ts.map

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

package/dist/types/extract.d.ts

@@ -1,151 +0,0 @@
-/**
- * Extract operator for Tabstack SDK
- */
-import { HTTPClient } from './util/http';
-import { MarkdownResponse, JsonResponse } from './types';
-export interface ExtractMarkdownOptions {
-    metadata?: boolean;
-    nocache?: boolean;
-}
-export interface ExtractJsonOptions {
-    nocache?: boolean;
-}
-/**
- * Extract operator for converting and extracting web content
- *
- * This class provides methods for extracting content from URLs in various formats:
- * - Markdown conversion
- * - Structured JSON extraction
- */
-export declare class Extract {
-    private httpClient;
-    constructor(httpClient: HTTPClient);
-    /**
-     * Convert URL content to Markdown format
-     *
-     * Fetches a URL and converts its HTML content to clean Markdown format with
-     * optional metadata extraction. By default, metadata is included in the content
-     * as YAML frontmatter. When metadata option is true, it's also returned as
-     * a separate field in the response.
-     *
-     * @param url - URL to fetch and convert to markdown
-     * @param options - Optional extraction options
-     * @param options.metadata - Include extracted metadata (Open Graph and HTML metadata) as a separate field in the response. Default: false
-     * @param options.nocache - Bypass cache and force fresh data retrieval. Default: false
-     *
-     * @returns MarkdownResponse containing the converted content and optional metadata
-     *
-     * @throws {BadRequestError} When URL is missing
-     * @throws {UnauthorizedError} When API key is invalid or missing
-     * @throws {InvalidURLError} When URL is invalid or inaccessible
-     * @throws {ServerError} When server fails to fetch or convert the content
-     *
-     * @example
-     * Basic usage:
-     * ```typescript
-     * const result = await tabs.extract.markdown('https://example.com/blog/article');
-     * console.log(result.content); // Markdown with YAML frontmatter
-     * ```
-     *
-     * @example
-     * With separate metadata field:
-     * ```typescript
-     * const result = await tabs.extract.markdown('https://example.com/blog/article', {
-     *   metadata: true
-     * });
-     * console.log(result.content);          // Markdown without frontmatter
-     * console.log(result.metadata?.title);  // "Example Article Title"
-     * console.log(result.metadata?.author); // "Example Author"
-     * console.log(result.metadata?.image);  // "https://example.com/images/article.jpg"
-     * ```
-     *
-     * @example
-     * Force fresh data retrieval:
-     * ```typescript
-     * const result = await tabs.extract.markdown('https://example.com/blog/article', {
-     *   nocache: true
-     * });
-     * ```
-     */
-    markdown(url: string, options?: ExtractMarkdownOptions): Promise<MarkdownResponse>;
-    /**
-     * Extract structured JSON from URL content
-     *
-     * Fetches a URL and extracts structured data according to a provided JSON schema.
-     * The schema defines what data to extract and its structure.
-     *
-     * @param url - URL to fetch and extract data from
-     * @param schema - JSON schema object defining the structure of data to extract
-     * @param options - Optional extraction options
-     * @param options.nocache - Bypass cache and force fresh data retrieval. Default: false
-     *
-     * @returns JsonResponse containing the extracted data matching the schema
-     *
-     * @throws {BadRequestError} When URL or schema is missing, or schema format is invalid
-     * @throws {UnauthorizedError} When API key is invalid or missing
-     * @throws {InvalidURLError} When URL is invalid
-     * @throws {ServerError} When server fails to fetch URL, page is too large, or JSON generation fails
-     *
-     * @example
-     * Extract news stories:
-     * ```typescript
-     * const schema = {
-     *   type: 'object',
-     *   properties: {
-     *     stories: {
-     *       type: 'array',
-     *       items: {
-     *         type: 'object',
-     *         properties: {
-     *           title: { type: 'string' },
-     *           points: { type: 'number' },
-     *           author: { type: 'string' }
-     *         },
-     *         required: ['title', 'points', 'author']
-     *       }
-     *     }
-     *   },
-     *   required: ['stories']
-     * };
-     *
-     * const result = await tabs.extract.json('https://news.ycombinator.com', schema);
-     * console.log(result.data.stories); // Array of story objects
-     * ```
-     *
-     * @example
-     * Extract product information:
-     * ```typescript
-     * const schema = {
-     *   type: 'object',
-     *   properties: {
-     *     name: { type: 'string' },
-     *     price: { type: 'number' },
-     *     inStock: { type: 'boolean' },
-     *     features: {
-     *       type: 'array',
-     *       items: { type: 'string' }
-     *     }
-     *   },
-     *   required: ['name', 'price', 'inStock']
-     * };
-     *
-     * const result = await tabs.extract.json(
-     *   'https://example-store.com/product/wireless-headphones',
-     *   schema
-     * );
-     * console.log(result.data.name);     // "Premium Wireless Headphones"
-     * console.log(result.data.price);    // 299.99
-     * console.log(result.data.inStock);  // true
-     * ```
-     *
-     * @example
-     * Force fresh data retrieval:
-     * ```typescript
-     * const result = await tabs.extract.json('https://news.ycombinator.com', schema, {
-     *   nocache: true
-     * });
-     * ```
-     */
-    json<T = unknown>(url: string, schema: Record<string, unknown>, options?: ExtractJsonOptions): Promise<JsonResponse<T>>;
-}
-//# sourceMappingURL=extract.d.ts.map

package/dist/types/extract.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract.d.ts","sourceRoot":"","sources":["../../src/extract.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEzD,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,kBAAkB;IACjC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;GAMG;AACH,qBAAa,OAAO;IACN,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA8CG;IACG,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAYxF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6EG;IACG,IAAI,CAAC,CAAC,GAAG,OAAO,EACpB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,OAAO,CAAC,EAAE,kBAAkB,GAC3B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;CAU5B"}

package/dist/types/extract.test.d.ts

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

package/dist/types/extract.test.d.ts.map

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

package/dist/types/generate.d.ts

@@ -1,113 +0,0 @@
-/**
- * Generate operator for Tabstack SDK
- */
-import { HTTPClient } from './util/http';
-import { JsonResponse } from './types';
-export interface GenerateJsonOptions {
-    nocache?: boolean;
-}
-/**
- * Generate operator for AI-powered content transformation
- *
- * This class provides methods for generating transformed content from URLs using AI,
- * allowing you to create summaries, restructure data, and enhance content based on
- * custom instructions.
- */
-export declare class Generate {
-    private httpClient;
-    constructor(httpClient: HTTPClient);
-    /**
-     * Generate transformed JSON with AI
-     *
-     * Fetches URL content, extracts data, and transforms it using AI based on custom
-     * instructions. Use this to generate new content, summaries, categorizations, or
-     * restructured data. Unlike extract.json() which extracts existing data, this
-     * method creates new content based on your instructions.
-     *
-     * @param url - URL to fetch content from
-     * @param schema - JSON schema object defining the structure of the transformed output
-     * @param instructions - Instructions describing how to transform the data. Example: "For each story, categorize it (tech/business/science/other) and write a one-sentence summary explaining what it's about in simple terms."
-     * @param options - Optional generation options
-     * @param options.nocache - Bypass cache and force fresh data retrieval. Default: false
-     *
-     * @returns JsonResponse containing the transformed data matching the schema
-     *
-     * @throws {BadRequestError} When URL, schema, or instructions are missing, or schema format is invalid
-     * @throws {UnauthorizedError} When API key is invalid or missing
-     * @throws {InvalidURLError} When URL is invalid
-     * @throws {ServerError} When server fails to fetch URL, page is too large, or data transformation fails
-     *
-     * @example
-     * Categorize and summarize news stories:
-     * ```typescript
-     * const schema = {
-     *   type: 'object',
-     *   properties: {
-     *     summaries: {
-     *       type: 'array',
-     *       items: {
-     *         type: 'object',
-     *         properties: {
-     *           title: { type: 'string' },
-     *           category: { type: 'string' },
-     *           summary: { type: 'string' }
-     *         },
-     *         required: ['title', 'category', 'summary']
-     *       }
-     *     }
-     *   },
-     *   required: ['summaries']
-     * };
-     *
-     * const result = await tabs.generate.json(
-     *   'https://news.ycombinator.com',
-     *   schema,
-     *   'For each story, categorize it (tech/business/science/other) and write a one-sentence summary explaining what it\'s about in simple terms.'
-     * );
-     *
-     * console.log(result.data.summaries);
-     * // [
-     * //   {
-     * //     title: "New AI Model Released",
-     * //     category: "tech",
-     * //     summary: "A research lab announced a new large language model that achieves state-of-the-art performance on reasoning tasks."
-     * //   },
-     * //   ...
-     * // ]
-     * ```
-     *
-     * @example
-     * Create structured analysis:
-     * ```typescript
-     * const schema = {
-     *   type: 'object',
-     *   properties: {
-     *     sentiment: { type: 'string' },
-     *     keyPoints: {
-     *       type: 'array',
-     *       items: { type: 'string' }
-     *     },
-     *     summary: { type: 'string' },
-     *     tags: {
-     *       type: 'array',
-     *       items: { type: 'string' }
-     *     }
-     *   },
-     *   required: ['sentiment', 'keyPoints', 'summary', 'tags']
-     * };
-     *
-     * const result = await tabs.generate.json(
-     *   'https://example.com/article',
-     *   schema,
-     *   'Analyze the sentiment (positive/negative/neutral), extract key points, create a brief summary, and add relevant tags'
-     * );
-     *
-     * console.log(result.data.sentiment);  // "positive"
-     * console.log(result.data.keyPoints);  // ["Key point 1", "Key point 2", ...]
-     * console.log(result.data.summary);    // "Brief summary of the article..."
-     * console.log(result.data.tags);       // ["technology", "innovation", ...]
-     * ```
-     */
-    json<T = unknown>(url: string, schema: Record<string, unknown>, instructions: string, options?: GenerateJsonOptions): Promise<JsonResponse<T>>;
-}
-//# sourceMappingURL=generate.d.ts.map

package/dist/types/generate.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"generate.d.ts","sourceRoot":"","sources":["../../src/generate.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAEvC,MAAM,WAAW,mBAAmB;IAClC,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;;;;GAMG;AACH,qBAAa,QAAQ;IACP,OAAO,CAAC,UAAU;gBAAV,UAAU,EAAE,UAAU;IAE1C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA2FG;IACG,IAAI,CAAC,CAAC,GAAG,OAAO,EACpB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC/B,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,mBAAmB,GAC5B,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC;CAW5B"}

package/dist/types/generate.test.d.ts

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

package/dist/types/generate.test.d.ts.map

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

package/dist/types/index.d.ts

@@ -1,52 +0,0 @@
-/**
- * Tabstack TypeScript/JavaScript SDK
- *
- * This SDK provides a TypeScript/JavaScript interface to the Tabstack API for web
- * content extraction, AI-powered content generation, and browser automation.
- *
- * @example
- * ```typescript
- * import { Tabstack } from '@tabstack/sdk';
- *
- * const tabs = new Tabstack({
- *   apiKey: process.env.TABSTACK_API_KEY!
- * });
- *
- * // Extract markdown
- * const result = await tabs.extract.markdown('https://example.com');
- * console.log(result.content);
- *
- * // Extract structured JSON
- * const schema = {
- *   type: 'object',
- *   properties: {
- *     stories: {
- *       type: 'array',
- *       items: {
- *         type: 'object',
- *         properties: {
- *           title: { type: 'string' },
- *           points: { type: 'number' },
- *           author: { type: 'string' }
- *         }
- *       }
- *     }
- *   }
- * };
- *
- * const data = await tabs.extract.json('https://news.ycombinator.com', schema);
- * console.log(data.data);
- * ```
- *
- * @packageDocumentation
- */
-export { Tabstack, TabstackOptions } from './client';
-export { Extract } from './extract';
-export { Generate } from './generate';
-export { Agent } from './agent';
-export { Metadata, MetadataFields, MarkdownResponse, JsonResponse, AutomateEvent, EventData, } from './types';
-export { TabstackError, BadRequestError, UnauthorizedError, InvalidURLError, ServerError, ServiceUnavailableError, APIError, } from './exceptions';
-export type { ExtractMarkdownOptions, ExtractJsonOptions } from './extract';
-export type { GenerateJsonOptions } from './generate';
-export type { AutomateOptions } from './agent';
-//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAGH,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAGrD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AACtC,OAAO,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAGhC,OAAO,EACL,QAAQ,EACR,cAAc,EACd,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,SAAS,GACV,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,aAAa,EACb,eAAe,EACf,iBAAiB,EACjB,eAAe,EACf,WAAW,EACX,uBAAuB,EACvB,QAAQ,GACT,MAAM,cAAc,CAAC;AAGtB,YAAY,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,WAAW,CAAC;AAC5E,YAAY,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACtD,YAAY,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC"}