@tabstack/sdk 1.0.4 → 2.0.0

package/README.md

@@ -1,485 +1,384 @@
-# TABStack AI TypeScript SDK
+# Tabstack TypeScript API Library
 
-TypeScript/JavaScript SDK for [TABStack AI](https://tabstack.ai) - Extract, Generate, and Automate web content with AI.
+[![NPM version](<https://img.shields.io/npm/v/@tabstack/sdk.svg?label=npm%20(stable)>)](https://npmjs.org/package/@tabstack/sdk) ![npm bundle size](https://img.shields.io/bundlephobia/minzip/@tabstack/sdk)
 
-## Features
+This library provides convenient access to the Tabstack REST API from server-side TypeScript or JavaScript.
 
-- **Extract**: Convert web pages to Markdown, generate schemas, and extract structured JSON data
-- **Generate**: Transform web content using AI with custom instructions
-- **Automate**: Execute complex browser automation tasks with natural language
-- **Type-Safe**: Full TypeScript support with comprehensive type definitions
-- **Zero Dependencies**: Uses only Node.js standard library
-- **Universal Module Support**: Works with CommonJS, ESM, and all TypeScript configurations
+The full API of this library can be found in [api.md](api.md).
 
-## Installation
+It is generated with [Stainless](https://www.stainless.com/).
+
+## MCP Server
+
+Use the Tabstack MCP Server to enable AI assistants to interact with this API, allowing them to explore endpoints, make test requests, and use documentation to help integrate this SDK into your application.
+
+[![Add to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en-US/install-mcp?name=tabstack-mcp&config=eyJuYW1lIjoidGFic3RhY2stbWNwIiwidHJhbnNwb3J0Ijoic3NlIiwidXJsIjoiaHR0cHM6Ly90YWJzdGFjay5zdGxtY3AuY29tL3NzZSJ9)
+[![Install in VS Code](https://img.shields.io/badge/_-Add_to_VS_Code-blue?style=for-the-badge&logo=data:image/svg%2bxml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGZpbGw9Im5vbmUiIHZpZXdCb3g9IjAgMCA0MCA0MCI+PHBhdGggZmlsbD0iI0VFRSIgZmlsbC1ydWxlPSJldmVub2RkIiBkPSJNMzAuMjM1IDM5Ljg4NGEyLjQ5MSAyLjQ5MSAwIDAgMS0xLjc4MS0uNzNMMTIuNyAyNC43OGwtMy40NiAyLjYyNC0zLjQwNiAyLjU4MmExLjY2NSAxLjY2NSAwIDAgMS0xLjA4Mi4zMzggMS42NjQgMS42NjQgMCAwIDEtMS4wNDYtLjQzMWwtMi4yLTJhMS42NjYgMS42NjYgMCAwIDEgMC0yLjQ2M0w3LjQ1OCAyMCA0LjY3IDE3LjQ1MyAxLjUwNyAxNC41N2ExLjY2NSAxLjY2NSAwIDAgMSAwLTIuNDYzbDIuMi0yYTEuNjY1IDEuNjY1IDAgMCAxIDIuMTMtLjA5N2w2Ljg2MyA1LjIwOUwyOC40NTIuODQ0YTIuNDg4IDIuNDg4IDAgMCAxIDEuODQxLS43MjljLjM1MS4wMDkuNjk5LjA5MSAxLjAxOS4yNDVsOC4yMzYgMy45NjFhMi41IDIuNSAwIDAgMSAxLjQxNSAyLjI1M3YuMDk5LS4wNDVWMzMuMzd2LS4wNDUuMDk1YTIuNTAxIDIuNTAxIDAgMCAxLTEuNDE2IDIuMjU3bC04LjIzNSAzLjk2MWEyLjQ5MiAyLjQ5MiAwIDAgMS0xLjA3Ny4yNDZabS43MTYtMjguOTQ3LTExLjk0OCA5LjA2MiAxMS45NTIgOS4wNjUtLjAwNC0xOC4xMjdaIi8+PC9zdmc+)](https://vscode.stainless.com/mcp/%7B%22name%22%3A%22tabstack-mcp%22%2C%22type%22%3A%22sse%22%2C%22url%22%3A%22https%3A%2F%2Ftabstack.stlmcp.com%2Fsse%22%7D)
+
+> Note: You may need to set environment variables in your MCP client.
 
-Install the SDK using your preferred package manager:
+## Installation
 
-### npm
-```bash
+```sh
 npm install @tabstack/sdk
 ```
 
-### Yarn
-```bash
-yarn add @tabstack/sdk
-```
+## Usage
 
-### pnpm
-```bash
-pnpm add @tabstack/sdk
-```
+The full API of this library can be found in [api.md](api.md).
 
-### Bun
-```bash
-bun add @tabstack/sdk
-```
+<!-- prettier-ignore -->
+```js
+import Tabstack from '@tabstack/sdk';
 
-### From Source
+const client = new Tabstack({
+  apiKey: process.env['TABSTACK_API_KEY'], // This is the default and can be omitted
+});
 
-Clone and build the SDK locally:
+const automateEvent = await client.agent.automate({
+  task: 'Find the top 3 trending repositories and extract their names, descriptions, and star counts',
+});
 
-```bash
-git clone https://github.com/tabstack/tabs-typescript.git
-cd tabs-typescript
-npm install
-npm run build
+console.log(automateEvent.data);
 ```
 
-To use the local build in your project:
+### Request & Response types
 
-```bash
-# Link the package globally
-npm link
+This library includes TypeScript definitions for all request params and response fields. You may import and use them like so:
 
-# In your project directory
-npm link @tabstack/sdk
-```
+<!-- prettier-ignore -->
+```ts
+import Tabstack from '@tabstack/sdk';
 
-Or install directly from the local path:
+const client = new Tabstack({
+  apiKey: process.env['TABSTACK_API_KEY'], // This is the default and can be omitted
+});
 
-```bash
-npm install /path/to/tabs-typescript
+const params: Tabstack.AgentAutomateParams = {
+  task: 'Find the top 3 trending repositories and extract their names, descriptions, and star counts',
+};
+const automateEvent: Tabstack.AutomateEvent = await client.agent.automate(params);
 ```
 
-## Quick Start
+Documentation for each method, request param, and response field are available in docstrings and will appear on hover in most modern editors.
 
-### Get Your API Key
+## Handling errors
 
-Sign up at [tabstack.ai](https://tabstack.ai) to get your API key.
+When the library is unable to connect to the API,
+or if the API returns a non-success status code (i.e., 4xx or 5xx response),
+a subclass of `APIError` will be thrown:
 
-### Basic Usage
+<!-- prettier-ignore -->
+```ts
+const automateEvent = await client.agent
+  .automate({
+    task: 'Find the top 3 trending repositories and extract their names, descriptions, and star counts',
+  })
+  .catch(async (err) => {
+    if (err instanceof Tabstack.APIError) {
+      console.log(err.status); // 400
+      console.log(err.name); // BadRequestError
+      console.log(err.headers); // {server: 'nginx', ...}
+    } else {
+      throw err;
+    }
+  });
+```
 
-#### ES Modules (ESM)
-```typescript
-import { TABStack } from '@tabstack/sdk';
+Error codes are as follows:
 
-const tabs = new TABStack({
-  apiKey: process.env.TABSTACK_API_KEY!
-});
+| Status Code | Error Type                 |
+| ----------- | -------------------------- |
+| 400         | `BadRequestError`          |
+| 401         | `AuthenticationError`      |
+| 403         | `PermissionDeniedError`    |
+| 404         | `NotFoundError`            |
+| 422         | `UnprocessableEntityError` |
+| 429         | `RateLimitError`           |
+| >=500       | `InternalServerError`      |
+| N/A         | `APIConnectionError`       |
 
-// Extract markdown from a URL
-const markdown = await tabs.extract.markdown('https://example.com');
-console.log(markdown.content);
-
-// Extract structured data with JSON schema
-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']
-};
+### Retries
 
-const data = await tabs.extract.json('https://news.ycombinator.com', schema);
-console.log(data.data);
-```
+Certain errors will be automatically retried 2 times by default, with a short exponential backoff.
+Connection errors (for example, due to a network connectivity problem), 408 Request Timeout, 409 Conflict,
+429 Rate Limit, and >=500 Internal errors will all be retried by default.
 
-#### CommonJS
-```javascript
-const { TABStack } = require('@tabstack/sdk');
+You can use the `maxRetries` option to configure or disable this:
 
-const tabs = new TABStack({
-  apiKey: process.env.TABSTACK_API_KEY
+<!-- prettier-ignore -->
+```js
+// Configure the default for all requests:
+const client = new Tabstack({
+  maxRetries: 0, // default is 2
 });
 
-// Extract markdown
-tabs.extract.markdown('https://example.com')
-  .then(result => {
-    console.log(result.content);
-  })
-  .catch(error => {
-    console.error('Error:', error.message);
-  });
+// Or, configure per-request:
+await client.agent.automate({ task: 'Find the top 3 trending repositories and extract their names, descriptions, and star counts' }, {
+  maxRetries: 5,
+});
 ```
 
-## Core Features
-
-### Extract Markdown
+### Timeouts
 
-Convert web pages to clean Markdown format:
+Requests time out after 1 minute by default. You can configure this with a `timeout` option:
 
-```typescript
-const result = await tabs.extract.markdown('https://example.com/blog/article', {
-  metadata: true,  // optional: include page metadata
-  nocache: false   // optional: bypass cache
+<!-- prettier-ignore -->
+```ts
+// Configure the default for all requests:
+const client = new Tabstack({
+  timeout: 20 * 1000, // 20 seconds (default is 1 minute)
 });
 
-console.log(result.content);
-console.log(result.metadata); // if metadata: true
+// Override per-request:
+await client.agent.automate({ task: 'Find the top 3 trending repositories and extract their names, descriptions, and star counts' }, {
+  timeout: 5 * 1000,
+});
 ```
 
-### Extract Structured Data
-
-Extract data matching a JSON schema:
-
-```typescript
-const schema = {
-  type: 'object',
-  properties: {
-    products: {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          name: { type: 'string' },
-          price: { type: 'number' },
-          inStock: { type: 'boolean' }
-        },
-        required: ['name', 'price', 'inStock']
-      }
-    }
-  },
-  required: ['products']
-};
+On timeout, an `APIConnectionTimeoutError` is thrown.
 
-const result = await tabs.extract.json('https://example.com/products', schema);
-console.log(result.data);
-```
+Note that requests which time out will be [retried twice by default](#retries).
 
-### Generate Schema
+## Advanced Usage
 
-Generate a JSON schema from web content:
+### Accessing raw Response data (e.g., headers)
 
-```typescript
-const schema = await tabs.extract.schema('https://news.ycombinator.com', {
-  instructions: 'extract top stories with title, points, and author'
-});
+The "raw" `Response` returned by `fetch()` can be accessed through the `.asResponse()` method on the `APIPromise` type that all methods return.
+This method returns as soon as the headers for a successful response are received and does not consume the response body, so you are free to write custom parsing or streaming logic.
 
-// Use the generated schema for extraction
-const result = await tabs.extract.json('https://news.ycombinator.com', schema);
-console.log(result.data);
-```
+You can also use the `.withResponse()` method to get the raw `Response` along with the parsed data.
+Unlike `.asResponse()` this method consumes the body, returning once it is parsed.
 
-### Generate Content
-
-Transform web content using AI:
-
-```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']
-};
+<!-- prettier-ignore -->
+```ts
+const client = new Tabstack();
 
-const result = await tabs.generate.json(
-  'https://news.ycombinator.com',
-  schema,
-  'Categorize each story and write a one-sentence summary'
-);
+const response = await client.agent
+  .automate({
+    task: 'Find the top 3 trending repositories and extract their names, descriptions, and star counts',
+  })
+  .asResponse();
+console.log(response.headers.get('X-My-Header'));
+console.log(response.statusText); // access the underlying Response object
 
-console.log(result.data);
+const { data: automateEvent, response: raw } = await client.agent
+  .automate({
+    task: 'Find the top 3 trending repositories and extract their names, descriptions, and star counts',
+  })
+  .withResponse();
+console.log(raw.headers.get('X-My-Header'));
+console.log(automateEvent.data);
 ```
 
-### Automate Tasks
-
-Execute browser automation tasks with streaming updates:
-
-```typescript
-for await (const event of tabs.automate.execute(
-  'Find the top 3 trending repositories and extract their details',
-  {
-    url: 'https://github.com/trending',
-    guardrails: 'browse and extract only',
-    maxIterations: 50
-  }
-)) {
-  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:', event.data.get('extractedData'));
-  }
-}
-```
+### Logging
 
-## Working with JSON Schemas
-
-The SDK uses standard [JSON Schema](https://json-schema.org/) format for defining data structures. You can define schemas manually or generate them automatically:
-
-### Manual Schema Definition
-
-```typescript
-const schema = {
-  type: 'object',
-  properties: {
-    name: { type: 'string', description: 'Person name' },
-    age: { type: 'number', description: 'Person age' },
-    isActive: { type: 'boolean', description: 'Active status' },
-    tags: {
-      type: 'array',
-      items: { type: 'string' }
-    },
-    addresses: {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          street: { type: 'string' },
-          city: { type: 'string' },
-          zipCode: { type: 'number' }
-        },
-        required: ['street', 'city', 'zipCode']
-      }
-    },
-    metadata: {
-      type: 'object',
-      properties: {
-        createdAt: { type: 'string' },
-        updatedAt: { type: 'string' }
-      },
-      required: ['createdAt', 'updatedAt']
-    }
-  },
-  required: ['name', 'age']
-};
-```
+> [!IMPORTANT]
+> All log messages are intended for debugging only. The format and content of log messages
+> may change between releases.
 
-### Automatic Schema Generation
+#### Log levels
 
-Let the AI generate a schema from any webpage:
+The log level can be configured in two ways:
 
-```typescript
-// Generate schema from content
-const schema = await tabs.extract.schema('https://news.ycombinator.com', {
-  instructions: 'extract stories with title, points, and author'
-});
+1. Via the `TABSTACK_LOG` environment variable
+2. Using the `logLevel` client option (overrides the environment variable if set)
 
-// Use it immediately
-const data = await tabs.extract.json('https://news.ycombinator.com', schema);
-```
+```ts
+import Tabstack from '@tabstack/sdk';
 
-## Error Handling
-
-Handle errors with specific error classes:
-
-```typescript
-import {
-  TABStackError,
-  UnauthorizedError,
-  InvalidURLError,
-  BadRequestError,
-  ServerError
-} from '@tabstack/sdk';
-
-try {
-  const result = await tabs.extract.markdown('https://example.com');
-} catch (error) {
-  if (error instanceof UnauthorizedError) {
-    console.error('Invalid API key');
-  } else if (error instanceof InvalidURLError) {
-    console.error('Invalid or inaccessible URL');
-  } else if (error instanceof TABStackError) {
-    console.error(`API error: ${error.message}`);
-  }
-}
+const client = new Tabstack({
+  logLevel: 'debug', // Show all log messages
+});
 ```
 
-### Error Classes
+Available log levels, from most to least verbose:
 
-- `TABStackError` - Base error class
-- `BadRequestError` - 400: Malformed request
-- `UnauthorizedError` - 401: Invalid API key
-- `InvalidURLError` - 422: Invalid or inaccessible URL
-- `ServerError` - 500: Internal server error
-- `ServiceUnavailableError` - 503: Service unavailable
-- `APIError` - Generic API error with status code
+- `'debug'` - Show debug messages, info, warnings, and errors
+- `'info'` - Show info messages, warnings, and errors
+- `'warn'` - Show warnings and errors (default)
+- `'error'` - Show only errors
+- `'off'` - Disable all logging
 
-## Requirements
+At the `'debug'` level, all HTTP requests and responses are logged, including headers and bodies.
+Some authentication-related headers are redacted, but sensitive data in request and response bodies
+may still be visible.
 
-- Node.js >= 20.0.0
-- TABStack API key ([get one here](https://tabstack.ai))
+#### Custom logger
 
-## Development & Testing
+By default, this library logs to `globalThis.console`. You can also provide a custom logger.
+Most logging libraries are supported, including [pino](https://www.npmjs.com/package/pino), [winston](https://www.npmjs.com/package/winston), [bunyan](https://www.npmjs.com/package/bunyan), [consola](https://www.npmjs.com/package/consola), [signale](https://www.npmjs.com/package/signale), and [@std/log](https://jsr.io/@std/log). If your logger doesn't work, please open an issue.
 
-This SDK includes a comprehensive testing suite with excellent code coverage and type safety.
+When providing a custom logger, the `logLevel` option still controls which messages are emitted, messages
+below the configured level will not be sent to your logger.
 
-### Running Tests
+```ts
+import Tabstack from '@tabstack/sdk';
+import pino from 'pino';
 
-```bash
-# Run all tests
-npm test
+const logger = pino();
+
+const client = new Tabstack({
+  logger: logger.child({ name: 'Tabstack' }),
+  logLevel: 'debug', // Send all messages to pino, allowing it to filter
+});
+```
 
-# Run unit tests only
-npm run test:unit
+### Making custom/undocumented requests
 
-# Run E2E tests only
-npm run test:e2e
+This library is typed for convenient access to the documented API. If you need to access undocumented
+endpoints, params, or response properties, the library can still be used.
 
-# Run tests in watch mode
-npm run test:watch
+#### Undocumented endpoints
 
-# Run tests with coverage report
-npm run test:coverage
+To make requests to undocumented endpoints, you can use `client.get`, `client.post`, and other HTTP verbs.
+Options on the client, such as retries, will be respected when making these requests.
 
-# Run TypeScript type tests
-npm run test:types
+```ts
+await client.post('/some/path', {
+  body: { some_prop: 'foo' },
+  query: { some_query_arg: 'bar' },
+});
 ```
 
-### Test Structure
+#### Undocumented request params
 
-The SDK includes multiple types of tests:
+To make requests using undocumented parameters, you may use `// @ts-expect-error` on the undocumented
+parameter. This library doesn't validate at runtime that the request matches the type, so any extra values you
+send will be sent as-is.
 
-**Unit Tests** (`src/**/*.test.ts`)
-- HTTPClient tests - HTTP request/response handling, error scenarios
-- Exception classes tests - Error creation and inheritance
-- Type classes tests - Serialization, deserialization, data access
-- Extract operator tests - Markdown, schema, and JSON extraction
-- Generate operator tests - AI-powered content generation
-- Automate operator tests - SSE streaming and event parsing
-- Client tests - Main client initialization and configuration
+```ts
+client.agent.automate({
+  // ...
+  // @ts-expect-error baz is not yet public
+  baz: 'undocumented option',
+});
+```
 
-**E2E Tests** (`test/e2e/`)
-- Complete workflows from client to operators
-- Real-world use case scenarios
-- Error handling and edge cases
-- Multi-operation workflows
+For requests with the `GET` verb, any extra params will be in the query, all other requests will send the
+extra param in the body.
 
-**Type Tests** (`test/types/`)
-- TypeScript type safety validation using `tsd`
-- Generic type inference
-- Type guard verification
-- Compile-time type checking
+If you want to explicitly send an extra argument, you can do so with the `query`, `body`, and `headers` request
+options.
 
-### Test Coverage
+#### Undocumented response properties
 
-The SDK maintains high test coverage across all modules:
+To access undocumented response properties, you may access the response object with `// @ts-expect-error` on
+the response object, or cast the response object to the requisite type. Like the request params, we do not
+validate or strip extra properties from the response from the API.
 
-- **172+ test cases** covering all major functionality
-- **~70%+ code coverage** across branches, functions, lines, and statements
-- **Mocked HTTP requests** using `nock` for fast, reliable tests
-- **Type-safe tests** with full TypeScript support
+### Customizing the fetch client
 
-### Test Technologies
+By default, this library expects a global `fetch` function is defined.
 
-- **Jest** - Test runner and assertion library
-- **ts-jest** - TypeScript support for Jest
-- **nock** - HTTP request mocking
-- **tsd** - TypeScript type definition testing
+If you want to use a different `fetch` function, you can either polyfill the global:
 
-### Writing Tests
+```ts
+import fetch from 'my-fetch';
 
-When contributing to the SDK, please:
+globalThis.fetch = fetch;
+```
 
-1. Write tests for all new features and bug fixes
-2. Maintain or improve code coverage
-3. Use descriptive test names that explain the behavior being tested
-4. Mock external HTTP requests using `nock`
-5. Test both success and error scenarios
-6. Add type tests for new public APIs
+Or pass it to the client:
 
-Example test structure:
+```ts
+import Tabstack from '@tabstack/sdk';
+import fetch from 'my-fetch';
 
-```typescript
-describe('Feature', () => {
-  describe('method', () => {
-    it('should handle success case', async () => {
-      // Arrange
-      const mockData = { result: 'success' };
-      nock('https://api.tabstack.ai')
-        .post('/endpoint')
-        .reply(200, mockData);
+const client = new Tabstack({ fetch });
+```
 
-      // Act
-      const result = await client.feature.method();
+### Fetch options
 
-      // Assert
-      expect(result).toEqual(mockData);
-    });
+If you want to set custom `fetch` options without overriding the `fetch` function, you can provide a `fetchOptions` object when instantiating the client or making a request. (Request-specific options override client options.)
 
-    it('should handle error case', async () => {
-      nock('https://api.tabstack.ai')
-        .post('/endpoint')
-        .reply(400, { error: 'Bad request' });
+```ts
+import Tabstack from '@tabstack/sdk';
 
-      await expect(client.feature.method()).rejects.toThrow(BadRequestError);
-    });
-  });
+const client = new Tabstack({
+  fetchOptions: {
+    // `RequestInit` options
+  },
 });
 ```
 
-## Contributing
+#### Configuring proxies
+
+To modify proxy behavior, you can provide custom `fetchOptions` that add runtime-specific proxy
+options to requests:
 
-We welcome contributions! Please see [CONTRIBUTING.md](CONTRIBUTING.md) for guidelines.
+<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/node.svg" align="top" width="18" height="21"> **Node** <sup>[[docs](https://github.com/nodejs/undici/blob/main/docs/docs/api/ProxyAgent.md#example---proxyagent-with-fetch)]</sup>
 
-### Quick Start for Contributors
+```ts
+import Tabstack from '@tabstack/sdk';
+import * as undici from 'undici';
 
-```bash
-# Fork and clone the repository
-git clone https://github.com/YOUR_USERNAME/tabs-typescript.git
-cd tabs-typescript
+const proxyAgent = new undici.ProxyAgent('http://localhost:8888');
+const client = new Tabstack({
+  fetchOptions: {
+    dispatcher: proxyAgent,
+  },
+});
+```
+
+<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/bun.svg" align="top" width="18" height="21"> **Bun** <sup>[[docs](https://bun.sh/guides/http/proxy)]</sup>
+
+```ts
+import Tabstack from '@tabstack/sdk';
+
+const client = new Tabstack({
+  fetchOptions: {
+    proxy: 'http://localhost:8888',
+  },
+});
+```
+
+<img src="https://raw.githubusercontent.com/stainless-api/sdk-assets/refs/heads/main/deno.svg" align="top" width="18" height="21"> **Deno** <sup>[[docs](https://docs.deno.com/api/deno/~/Deno.createHttpClient)]</sup>
 
-# Install dependencies
-npm install
+```ts
+import Tabstack from 'npm:@tabstack/sdk';
 
-# Run checks locally before submitting PR
-npm run lint        # Check for linting errors
-npm run format:check # Check formatting
-npm test            # Run all tests
-npm run build       # Verify builds work
+const httpClient = Deno.createHttpClient({ proxy: { url: 'http://localhost:8888' } });
+const client = new Tabstack({
+  fetchOptions: {
+    client: httpClient,
+  },
+});
 ```
 
-### Pull Request Requirements
+## Frequently Asked Questions
+
+## Semantic versioning
+
+This package generally follows [SemVer](https://semver.org/spec/v2.0.0.html) conventions, though certain backwards-incompatible changes may be released as minor versions:
+
+1. Changes that only affect static types, without breaking runtime behavior.
+2. Changes to library internals which are technically public but not intended or documented for external use. _(Please open a GitHub issue to let us know if you are relying on such internals.)_
+3. Changes that we do not expect to impact the vast majority of users in practice.
 
-All PRs must pass these checks before merging:
+We take backwards-compatibility seriously and work hard to ensure you can rely on a smooth upgrade experience.
 
-- ✅ **Lint** - Code style and formatting (ESLint + Prettier)
-- ✅ **Node 20, 22, 24** - Tests and builds on all supported Node versions
-- ✅ **Code Review** - Approval from maintainers
+We are keen for your feedback; please open an [issue](https://www.github.com/Mozilla-Ocho/tabstack-typescript/issues) with questions, bugs, or suggestions.
 
-See [CONTRIBUTING.md](CONTRIBUTING.md) for detailed guidelines.
+## Requirements
+
+TypeScript >= 4.9 is supported.
+
+The following runtimes are supported:
 
-## License
+- Web browsers (Up-to-date Chrome, Firefox, Safari, Edge, and more)
+- Node.js 20 LTS or later ([non-EOL](https://endoflife.date/nodejs)) versions.
+- Deno v1.28.0 or higher.
+- Bun 1.0 or later.
+- Cloudflare Workers.
+- Vercel Edge Runtime.
+- Jest 28 or greater with the `"node"` environment (`"jsdom"` is not supported at this time).
+- Nitro v2.6 or greater.
 
-Apache
+Note that React Native is not supported at this time.
 
-## Support
+If you are interested in other runtime environments, please open or upvote an issue on GitHub.
+
+## Contributing
 
-- Documentation: [https://docs.tabstack.ai](https://docs.tabstack.ai)
-- GitHub Issues: [https://github.com/tabstack/tabs-typescript/issues](https://github.com/tabstack/tabs-typescript/issues)
-- Website: [https://tabstack.ai](https://tabstack.ai)
+See [the contributing documentation](./CONTRIBUTING.md).