@tabstack/sdk 1.0.5 → 2.1.0

package/src/resources/extract.ts

@@ -0,0 +1,248 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+
+export class Extract extends APIResource {
+  /**
+   * Fetches a URL and extracts structured data according to a provided JSON schema
+   *
+   * @example
+   * ```ts
+   * const response = await client.extract.json({
+   *   json_schema: {
+   *     properties: {
+   *       stories: {
+   *         items: {
+   *           properties: {
+   *             author: {
+   *               description: 'Author username',
+   *               type: 'string',
+   *             },
+   *             points: {
+   *               description: 'Story points',
+   *               type: 'number',
+   *             },
+   *             title: {
+   *               description: 'Story title',
+   *               type: 'string',
+   *             },
+   *           },
+   *           type: 'object',
+   *         },
+   *         type: 'array',
+   *       },
+   *     },
+   *     type: 'object',
+   *   },
+   *   url: 'https://news.ycombinator.com',
+   * });
+   * ```
+   */
+  json(body: ExtractJsonParams, options?: RequestOptions): APIPromise<ExtractJsonResponse> {
+    return this._client.post('/extract/json', { body, ...options });
+  }
+
+  /**
+   * Fetches a URL and converts its HTML content to clean Markdown format with
+   * optional metadata extraction
+   *
+   * @example
+   * ```ts
+   * const response = await client.extract.markdown({
+   *   url: 'https://example.com/blog/article',
+   * });
+   * ```
+   */
+  markdown(body: ExtractMarkdownParams, options?: RequestOptions): APIPromise<ExtractMarkdownResponse> {
+    return this._client.post('/extract/markdown', { body, ...options });
+  }
+}
+
+export type ExtractJsonResponse = { [key: string]: unknown };
+
+export interface ExtractMarkdownResponse {
+  /**
+   * The markdown content (includes metadata as YAML frontmatter by default)
+   */
+  content: string;
+
+  /**
+   * The URL that was converted to markdown
+   */
+  url: string;
+
+  /**
+   * Extracted metadata from the page (only included when metadata parameter is true)
+   */
+  metadata?: ExtractMarkdownResponse.Metadata;
+}
+
+export namespace ExtractMarkdownResponse {
+  /**
+   * Extracted metadata from the page (only included when metadata parameter is true)
+   */
+  export interface Metadata {
+    /**
+     * Author information from HTML metadata
+     */
+    author?: string;
+
+    /**
+     * Document creation date (ISO 8601)
+     */
+    created_at?: string;
+
+    /**
+     * Creator application (e.g., "Microsoft Word")
+     */
+    creator?: string;
+
+    /**
+     * Page description from Open Graph or HTML
+     */
+    description?: string;
+
+    /**
+     * Featured image URL from Open Graph
+     */
+    image?: string;
+
+    /**
+     * PDF keywords as array
+     */
+    keywords?: Array<string>;
+
+    /**
+     * Document modification date (ISO 8601)
+     */
+    modified_at?: string;
+
+    /**
+     * Number of pages (PDF documents)
+     */
+    page_count?: number;
+
+    /**
+     * PDF version (e.g., "1.5")
+     */
+    pdf_version?: string;
+
+    /**
+     * PDF producer software (e.g., "Adobe PDF Library")
+     */
+    producer?: string;
+
+    /**
+     * Publisher information from Open Graph
+     */
+    publisher?: string;
+
+    /**
+     * Site name from Open Graph
+     */
+    site_name?: string;
+
+    /**
+     * PDF-specific metadata fields (populated for PDF documents) PDF subject or
+     * summary
+     */
+    subject?: string;
+
+    /**
+     * Page title from Open Graph or HTML
+     */
+    title?: string;
+
+    /**
+     * Content type from Open Graph (e.g., article, website)
+     */
+    type?: string;
+
+    /**
+     * Canonical URL from Open Graph
+     */
+    url?: string;
+  }
+}
+
+export interface ExtractJsonParams {
+  /**
+   * JSON schema definition that describes the structure of data to extract.
+   */
+  json_schema: unknown;
+
+  /**
+   * URL to fetch and extract data from
+   */
+  url: string;
+
+  /**
+   * Optional geotargeting parameters for proxy requests
+   */
+  geo_target?: ExtractJsonParams.GeoTarget;
+
+  /**
+   * Bypass cache and force fresh data retrieval
+   */
+  nocache?: boolean;
+}
+
+export namespace ExtractJsonParams {
+  /**
+   * Optional geotargeting parameters for proxy requests
+   */
+  export interface GeoTarget {
+    /**
+     * Country code using ISO 3166-1 alpha-2 standard (2 letters, e.g., "US", "GB",
+     * "JP"). See: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
+     */
+    country?: string;
+  }
+}
+
+export interface ExtractMarkdownParams {
+  /**
+   * URL to fetch and convert to markdown
+   */
+  url: string;
+
+  /**
+   * Optional geotargeting parameters for proxy requests
+   */
+  geo_target?: ExtractMarkdownParams.GeoTarget;
+
+  /**
+   * Include extracted metadata (Open Graph and HTML metadata) as a separate field in
+   * the response
+   */
+  metadata?: boolean;
+
+  /**
+   * Bypass cache and force fresh data retrieval
+   */
+  nocache?: boolean;
+}
+
+export namespace ExtractMarkdownParams {
+  /**
+   * Optional geotargeting parameters for proxy requests
+   */
+  export interface GeoTarget {
+    /**
+     * Country code using ISO 3166-1 alpha-2 standard (2 letters, e.g., "US", "GB",
+     * "JP"). See: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
+     */
+    country?: string;
+  }
+}
+
+export declare namespace Extract {
+  export {
+    type ExtractJsonResponse as ExtractJsonResponse,
+    type ExtractMarkdownResponse as ExtractMarkdownResponse,
+    type ExtractJsonParams as ExtractJsonParams,
+    type ExtractMarkdownParams as ExtractMarkdownParams,
+  };
+}

package/src/resources/generate.ts

@@ -0,0 +1,89 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+import { APIResource } from '../core/resource';
+import { APIPromise } from '../core/api-promise';
+import { RequestOptions } from '../internal/request-options';
+
+export class Generate extends APIResource {
+  /**
+   * Fetches URL content, extracts data, and transforms it using AI based on custom
+   * instructions. Use this to generate new content, summaries, or restructured data.
+   *
+   * @example
+   * ```ts
+   * const response = await client.generate.json({
+   *   instructions:
+   *     "For each story, categorize it (tech/business/science/other) and write a one-sentence summary explaining what it's about in simple terms.",
+   *   json_schema: {
+   *     properties: {
+   *       summaries: {
+   *         items: {
+   *           properties: {
+   *             category: {
+   *               description: 'Story category (tech/business/science/etc)',
+   *               type: 'string',
+   *             },
+   *             summary: { description: 'One-sentence summary of the story', type: 'string' },
+   *             title: { description: 'Story title', type: 'string' },
+   *           },
+   *           type: 'object',
+   *         },
+   *         type: 'array',
+   *       },
+   *     },
+   *     type: 'object',
+   *   },
+   *   url: 'https://news.ycombinator.com',
+   * });
+   * ```
+   */
+  json(body: GenerateJsonParams, options?: RequestOptions): APIPromise<GenerateJsonResponse> {
+    return this._client.post('/generate/json', { body, ...options });
+  }
+}
+
+export type GenerateJsonResponse = { [key: string]: unknown };
+
+export interface GenerateJsonParams {
+  /**
+   * Instructions describing how to transform the data
+   */
+  instructions: string;
+
+  /**
+   * JSON schema defining the structure of the transformed output
+   */
+  json_schema: unknown;
+
+  /**
+   * URL to fetch content from
+   */
+  url: string;
+
+  /**
+   * Optional geotargeting parameters for proxy requests
+   */
+  geo_target?: GenerateJsonParams.GeoTarget;
+
+  /**
+   * Bypass cache and force fresh data retrieval
+   */
+  nocache?: boolean;
+}
+
+export namespace GenerateJsonParams {
+  /**
+   * Optional geotargeting parameters for proxy requests
+   */
+  export interface GeoTarget {
+    /**
+     * Country code using ISO 3166-1 alpha-2 standard (2 letters, e.g., "US", "GB",
+     * "JP"). See: https://en.wikipedia.org/wiki/ISO_3166-1_alpha-2
+     */
+    country?: string;
+  }
+}
+
+export declare namespace Generate {
+  export { type GenerateJsonResponse as GenerateJsonResponse, type GenerateJsonParams as GenerateJsonParams };
+}

package/src/resources/index.ts

@@ -0,0 +1,17 @@
+// File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+export {
+  Agent,
+  type AutomateEvent,
+  type ResearchEvent,
+  type AgentAutomateParams,
+  type AgentResearchParams,
+} from './agent';
+export {
+  Extract,
+  type ExtractJsonResponse,
+  type ExtractMarkdownResponse,
+  type ExtractJsonParams,
+  type ExtractMarkdownParams,
+} from './extract';
+export { Generate, type GenerateJsonResponse, type GenerateJsonParams } from './generate';

package/src/resources.ts

@@ -0,0 +1 @@
+export * from './resources/index';

package/src/streaming.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/streaming instead */
+export * from './core/streaming';

package/src/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  // this config is included in the published src directory to prevent TS errors
+  // from appearing when users go to source, and VSCode opens the source .ts file
+  // via declaration maps
+  "include": ["index.ts"],
+  "compilerOptions": {
+    "target": "ES2015",
+    "lib": ["DOM", "DOM.Iterable", "ES2018"],
+    "moduleResolution": "node"
+  }
+}

package/src/uploads.ts

@@ -0,0 +1,2 @@
+/** @deprecated Import from ./core/uploads instead */
+export * from './core/uploads';

package/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = '2.1.0'; // x-release-please-version

package/streaming.d.mts

@@ -0,0 +1,2 @@
+export * from "./core/streaming.mjs";
+//# sourceMappingURL=streaming.d.mts.map

package/streaming.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.d.mts","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":""}

package/streaming.d.ts

@@ -0,0 +1,2 @@
+export * from "./core/streaming.js";
+//# sourceMappingURL=streaming.d.ts.map

package/streaming.d.ts.map

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

package/streaming.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("./internal/tslib.js");
+/** @deprecated Import from ./core/streaming instead */
+tslib_1.__exportStar(require("./core/streaming.js"), exports);
+//# sourceMappingURL=streaming.js.map

package/streaming.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.js","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":";;;AAAA,uDAAuD;AACvD,8DAAiC"}

package/streaming.mjs

@@ -0,0 +1,2 @@
+export * from "./core/streaming.mjs";
+//# sourceMappingURL=streaming.mjs.map

package/streaming.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.mjs","sourceRoot":"","sources":["src/streaming.ts"],"names":[],"mappings":""}

package/uploads.d.mts

@@ -0,0 +1,2 @@
+export * from "./core/uploads.mjs";
+//# sourceMappingURL=uploads.d.mts.map

package/uploads.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.d.mts","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":""}

package/uploads.d.ts

@@ -0,0 +1,2 @@
+export * from "./core/uploads.js";
+//# sourceMappingURL=uploads.d.ts.map

package/uploads.d.ts.map

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

package/uploads.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("./internal/tslib.js");
+/** @deprecated Import from ./core/uploads instead */
+tslib_1.__exportStar(require("./core/uploads.js"), exports);
+//# sourceMappingURL=uploads.js.map

package/uploads.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.js","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":";;;AAAA,qDAAqD;AACrD,4DAA+B"}

package/uploads.mjs

@@ -0,0 +1,2 @@
+export * from "./core/uploads.mjs";
+//# sourceMappingURL=uploads.mjs.map

package/uploads.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"uploads.mjs","sourceRoot":"","sources":["src/uploads.ts"],"names":[],"mappings":""}

package/version.d.mts

@@ -0,0 +1,2 @@
+export declare const VERSION = "2.1.0";
+//# sourceMappingURL=version.d.mts.map

package/version.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.mts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "2.1.0";
+//# sourceMappingURL=version.d.ts.map

package/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/version.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+exports.VERSION = '2.1.0'; // x-release-please-version
+//# sourceMappingURL=version.js.map

package/version.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.js","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":";;;AAAa,QAAA,OAAO,GAAG,OAAO,CAAC,CAAC,2BAA2B"}

package/version.mjs

@@ -0,0 +1,2 @@
+export const VERSION = '2.1.0'; // x-release-please-version
+//# sourceMappingURL=version.mjs.map

package/version.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.mjs","sourceRoot":"","sources":["src/version.ts"],"names":[],"mappings":"AAAA,MAAM,CAAC,MAAM,OAAO,GAAG,OAAO,CAAC,CAAC,2BAA2B"}

package/dist/cjs/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/cjs/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"}