@tiny-fish/sdk 0.0.6 → 0.0.7

package/README.md

@@ -1,8 +1,15 @@
 # TinyFish TypeScript SDK
 
-The official TypeScript SDK for [TinyFish](https://agent.tinyfish.ai)
+Typed access to TinyFish web agents, fetch extraction, remote browser sessions, run history, and search.
 
-For SDK design conventions and how new API surfaces should be added, see [ARCHITECTURE.md](ARCHITECTURE.md).
+Use the SDK when you want to:
+
+- automate a page with a natural-language goal
+- stream live progress events and a browser preview URL
+- queue jobs and poll them later
+- fetch clean page content from up to 10 URLs at once
+- create a remote browser session for direct CDP control
+- query TinyFish Search from the same client
 
 ## Installation
 
@@ -10,81 +17,26 @@ For SDK design conventions and how new API surfaces should be added, see [ARCHIT
 npm install @tiny-fish/sdk
 ```
 
-Requires Node.js 18+. Also works with Bun and Deno.
-
-## Get your API key
+Requirements:
 
-Sign up and grab your key at [agent.tinyfish.ai/api-keys](https://agent.tinyfish.ai/api-keys).
+- Node.js 18+
+- a TinyFish API key from [agent.tinyfish.ai/api-keys](https://agent.tinyfish.ai/api-keys)
 
-## Quickstart
+Authenticate with either the constructor or `TINYFISH_API_KEY`:
 
-```typescript
+```ts
 import { TinyFish } from "@tiny-fish/sdk";
 
-const client = new TinyFish({ apiKey: "your-api-key" });
-
-const stream = await client.agent.stream(
-  {
-    goal: "What is the current Bitcoin price?",
-    url: "https://www.coinbase.com/price/bitcoin",
-  },
-  {
-    onProgress: (e) => console.log(`  > ${e.purpose}`),
-    onComplete: (e) => console.log(e.result),
-  },
-);
-
-for await (const event of stream) {
-  // Callbacks fire automatically during iteration
-}
-```
-
-Need per-request cancellation without changing the client-wide timeout? Pass an `AbortSignal` as the optional second argument:
-
-```typescript
-const controller = new AbortController();
-
-const stream = await client.agent.stream(
-  {
-    goal: "Extract the top 5 headlines",
-    url: "https://news.ycombinator.com",
-  },
-  {
-    signal: controller.signal,
-  },
-);
-
-controller.abort();
-```
-
-Or set the `TINYFISH_API_KEY` environment variable and omit `apiKey`:
-
-```typescript
-const client = new TinyFish();
+const client = new TinyFish({
+  apiKey: process.env.TINYFISH_API_KEY,
+});
 ```
 
-> All methods are async and return promises. There is no synchronous client — JavaScript is async-native.
-
-## Methods
-
-| Method | Description | Returns | Blocks? |
-|--------|-------------|---------|---------|
-| [`agent.stream()`](#agentstream--real-time-events) | Stream live SSE events as the agent works | `AgentStream` | No |
-| [`agent.run()`](#agentrun--block-until-done) | Run an automation, wait for the result | `AgentRunResponse` | Yes |
-| [`agent.queue()`](#agentqueue--fire-and-forget) | Start an automation, return immediately | `AgentRunAsyncResponse` | No |
-| [`browser.sessions.create()`](#browsersessionscreate--create-a-browser-session) | Create a remote browser session | `BrowserSession` | — |
-| [`fetch.getContents()`](#fetchgetcontents--fetch-and-extract-content) | Fetch URLs and return extracted content | `FetchResponse` | — |
-| [`runs.get()`](#runsget--retrieve-a-single-run) | Retrieve a single run by ID | `Run` | — |
-| [`runs.list()`](#runslist--list-and-filter-runs) | List runs with filtering, sorting, pagination | `RunListResponse` | — |
-| [`search.query()`](#searchquery--run-a-web-search) | Run a web search query | `SearchQueryResponse` | — |
-
----
-
-### `agent.stream()` — real-time events
+## Quickstart
 
-Opens a Server-Sent Events stream. You get live progress updates as the agent works, plus a URL for a live browser preview. This is the recommended integration method.
+`agent.stream()` is the best default for product integrations because it gives you progress updates while the run is happening.
 
-```typescript
+```ts
 import { TinyFish } from "@tiny-fish/sdk";
 
 const client = new TinyFish();
@@ -95,29 +47,23 @@ const stream = await client.agent.stream(
     url: "https://news.ycombinator.com",
   },
   {
-    onStarted: (e) => console.log(`Started: ${e.run_id}`),
-    onStreamingUrl: (e) => console.log(`Watch: ${e.streaming_url}`),
-    onProgress: (e) => console.log(`  > ${e.purpose}`),
-    onComplete: (e) => console.log(`Done: ${e.status}`),
+    onStarted: (event) => console.log(`Run: ${event.run_id}`),
+    onStreamingUrl: (event) => console.log(`Watch live: ${event.streaming_url}`),
+    onProgress: (event) => console.log(`> ${event.purpose}`),
+    onComplete: (event) => console.log(event.result),
   },
 );
 
 for await (const event of stream) {
-  // Callbacks fire automatically during iteration.
-  // You can also inspect events directly:
   if (event.type === "COMPLETE") {
-    console.log(event.result);
+    console.log(`Finished with status ${event.status}`);
   }
 }
 ```
 
-**Returns `AgentStream`** — an async iterable you iterate with `for await`. Events arrive in order: `STARTED` → `STREAMING_URL` → `PROGRESS` (repeated) → `COMPLETE`.
-
-Call `stream.close()` to abort early and stop yielding events.
-
-The second argument also accepts `signal` for request-scoped cancellation:
+Need request-scoped cancellation without changing the client-wide timeout? Pass an `AbortSignal` as the optional second argument:
 
-```typescript
+```ts
 const controller = new AbortController();
 
 const stream = await client.agent.stream(
@@ -127,53 +73,67 @@ const stream = await client.agent.stream(
   },
   {
     signal: controller.signal,
-    onProgress: (e) => console.log(e.purpose),
   },
 );
 
 controller.abort();
 ```
 
-See the [Streaming Guide](docs/streaming-guide.md) for the full event lifecycle, event types, and advanced patterns.
+## Choose an API
 
----
+| Method | Use it when | Returns |
+| --- | --- | --- |
+| `client.agent.stream()` | You want live events and a browser preview URL | `AgentStream` |
+| `client.agent.run()` | You want one blocking request that waits for the final result | `AgentRunResponse` |
+| `client.agent.queue()` | You want to enqueue work and check back later | `AgentRunAsyncResponse` |
+| `client.fetch.getContents()` | You want extracted page content without running a browser agent | `FetchResponse` |
+| `client.browser.sessions.create()` | You want a remote browser session and CDP connection info | `BrowserSession` |
+| `client.runs.get()` | You already have a `run_id` and need the latest state | `Run` |
+| `client.runs.list()` | You want to list or filter historical runs | `RunListResponse` |
+| `client.search.query()` | You want TinyFish Search results | `SearchQueryResponse` |
 
-### `agent.run()` — block until done
+## Core workflows
 
-Sends the automation and waits for it to finish. Returns the full result in one shot.
+### Run and wait
 
-```typescript
-import { TinyFish, RunStatus, BrowserProfile, ProxyCountryCode } from "@tiny-fish/sdk";
-import type { ProxyConfig } from "@tiny-fish/sdk";
+Use `agent.run()` for scripts, cron jobs, and backend tasks that should block until the result is ready.
+
+```ts
+import {
+  BrowserProfile,
+  ProxyCountryCode,
+  RunStatus,
+  TinyFish,
+} from "@tiny-fish/sdk";
 
 const client = new TinyFish();
 
 const response = await client.agent.run({
-  goal: "Extract the top 5 headlines",              // required — what to do on the page
-  url: "https://news.ycombinator.com",              // required — URL to open
-  browser_profile: BrowserProfile.STEALTH,           // optional — "lite" (default) or "stealth"
-  proxy_config: {                                    // optional — proxy settings
+  goal: "Find the price of the latest MacBook Pro",
+  url: "https://www.apple.com/shop/buy-mac/macbook-pro",
+  browser_profile: BrowserProfile.STEALTH,
+  proxy_config: {
     enabled: true,
-    country_code: ProxyCountryCode.US,               // optional — US, GB, CA, DE, FR, JP, AU
+    country_code: ProxyCountryCode.US,
   },
 });
 
 if (response.status === RunStatus.COMPLETED) {
   console.log(response.result);
 } else {
-  console.log(`Failed: ${response.error?.message}`);
+  console.error(response.error?.message);
 }
 ```
 
-Like `stream()`, `run()` accepts an optional second argument with `signal`:
+`run()` also accepts an optional second argument with `signal`:
 
-```typescript
+```ts
 const controller = new AbortController();
 
 const response = await client.agent.run(
   {
-    goal: "Extract the top 5 headlines",
-    url: "https://news.ycombinator.com",
+    goal: "Extract the page title",
+    url: "https://example.com",
   },
   {
     signal: controller.signal,
@@ -181,113 +141,51 @@ const response = await client.agent.run(
 );
 ```
 
-**Returns `AgentRunResponse`:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `status` | `RunStatus` | `COMPLETED`, `FAILED`, etc. |
-| `run_id` | `string \| null` | Unique run identifier |
-| `result` | `Record<string, unknown> \| null` | Extracted data (`null` if failed) |
-| `error` | `RunError \| null` | Error details (`null` if succeeded) |
-| `num_of_steps` | `number` | Number of steps the agent took |
-| `started_at` | `string \| null` | ISO 8601 timestamp when the run started |
-| `finished_at` | `string \| null` | ISO 8601 timestamp when the run finished |
-
----
-
-### `agent.queue()` — fire and forget
+### Queue and poll
 
-Starts the automation in the background and returns a `run_id` immediately. Poll with `runs.get()` when you're ready for the result.
+Use `agent.queue()` when you do not want to keep the request open.
 
-```typescript
-import { TinyFish, RunStatus } from "@tiny-fish/sdk";
+```ts
+import { RunStatus, TinyFish } from "@tiny-fish/sdk";
 
 const client = new TinyFish();
 
 const queued = await client.agent.queue({
-  goal: "Extract the top 5 headlines",
-  url: "https://news.ycombinator.com",
+  goal: "Extract all job titles from the careers page",
+  url: "https://example.com/careers",
 });
 
 if (queued.error) {
-  console.error(`Failed to queue: ${queued.error.message}`);
-  process.exit(1);
+  throw new Error(queued.error.message);
 }
 
-console.log(`Run started: ${queued.run_id}`);
+let run = await client.runs.get(queued.run_id);
 
-// Poll for completion
-while (true) {
-  const run = await client.runs.get(queued.run_id);
-  if (run.status === RunStatus.COMPLETED || run.status === RunStatus.FAILED) {
-    console.log(run.result);
-    break;
-  }
-  await new Promise((r) => setTimeout(r, 5000));
+while (run.status === RunStatus.PENDING || run.status === RunStatus.RUNNING) {
+  await new Promise((resolve) => setTimeout(resolve, 5000));
+  run = await client.runs.get(run.run_id);
 }
-```
-
-`queue()` also accepts an optional `{ signal }` second argument when you want to cancel just that enqueue request.
-
-**Returns `AgentRunAsyncResponse`** — a discriminated union. Check `error` to narrow the type:
 
-```typescript
-const response = await client.agent.queue({ goal, url });
-if (response.error) {
-  // response.run_id is null here
-  console.error(response.error.message);
+if (run.status === RunStatus.COMPLETED) {
+  console.log(run.result);
 } else {
-  // response.run_id is string here
-  const run = await client.runs.get(response.run_id);
+  console.error(run.error?.message ?? `Run ended with status: ${run.status}`);
 }
 ```
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `run_id` | `string \| null` | Run ID to poll with `runs.get()` |
-| `error` | `RunError \| null` | Error if queuing itself failed |
+`queue()` also accepts an optional second argument with `signal` for cancelling just the enqueue request.
 
----
+### Fetch clean content
 
-### `browser.sessions.create()` — create a browser session
-
-Create a remote browser session and get back the connection details for direct CDP control. Pass a `url` to hint routing and start the session on a target page, or omit it to start at `about:blank`.
-
-```typescript
-import { TinyFish } from "@tiny-fish/sdk";
+Use `fetch.getContents()` when you want extracted content from URLs without a browser-agent run.
 
-const client = new TinyFish();
-
-const session = await client.browser.sessions.create({
-  url: "https://example.com",
-});
-
-console.log(session.session_id);
-console.log(session.cdp_url);
-console.log(session.base_url);
-```
-
-**Returns `BrowserSession`:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `session_id` | `string` | Unique browser session identifier |
-| `cdp_url` | `string` | CDP WebSocket URL for connecting to the browser |
-| `base_url` | `string` | HTTPS base URL for the browser session |
-
----
-
-### `fetch.getContents()` — fetch and extract content
-
-Fetch one or more URLs and return clean extracted content in markdown, html, or json form.
-
-```typescript
+```ts
 import { FetchFormat, TinyFish } from "@tiny-fish/sdk";
 
 const client = new TinyFish();
 
 const response = await client.fetch.getContents({
-  urls: ["https://example.com"],
+  urls: ["https://example.com", "https://example.org"],
   format: FetchFormat.Markdown,
   links: true,
   image_links: false,
@@ -297,100 +195,71 @@ console.log(response.results);
 console.log(response.errors);
 ```
 
-**Returns `FetchResponse`:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `results` | `FetchResult[]` | Successfully fetched URLs and extracted content |
-| `errors` | `FetchError[]` | URLs that failed to fetch |
-
-`FetchResult.text` is:
+`fetch.getContents()` accepts 1 to 10 URLs. `FetchResult.text` is:
 
-- `string` for `markdown` and `html`
-- `Record<string, unknown>` for `json`
+- `string` for `FetchFormat.Markdown` and `FetchFormat.Html`
+- `Record<string, unknown>` for `FetchFormat.Json`
 - `null` if extraction failed for that item
 
----
+### Create a browser session
 
-### `runs.get()` — retrieve a single run
+Use `browser.sessions.create()` when you want connection details for direct browser control.
 
-Fetch the full details of a run by its ID.
+```ts
+import { TinyFish } from "@tiny-fish/sdk";
 
-```typescript
-const run = await client.runs.get("run_abc123");
+const client = new TinyFish();
 
-console.log(run.status);          // PENDING, RUNNING, COMPLETED, FAILED, CANCELLED
-console.log(run.result);
-console.log(run.goal);
-console.log(run.streaming_url);   // live browser URL (while RUNNING)
-console.log(run.browser_config);  // proxy/browser settings that were used
+const session = await client.browser.sessions.create({
+  url: "https://example.com",
+});
+
+console.log(session.session_id);
+console.log(session.cdp_url);
+console.log(session.base_url);
 ```
 
-**Returns `Run`:**
+### Inspect and list runs
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `run_id` | `string` | Unique identifier |
-| `status` | `RunStatus` | `PENDING`, `RUNNING`, `COMPLETED`, `FAILED`, `CANCELLED` |
-| `goal` | `string` | The goal that was given |
-| `result` | `Record<string, unknown> \| null` | Extracted data (`null` if not completed) |
-| `error` | `RunError \| null` | Error details (`null` if succeeded) |
-| `streaming_url` | `string \| null` | Live browser URL (available while running) |
-| `browser_config` | `BrowserConfig \| null` | Proxy/browser settings used |
-| `created_at` | `string` | ISO 8601 timestamp when the run was created |
-| `started_at` | `string \| null` | ISO 8601 timestamp when execution started |
-| `finished_at` | `string \| null` | ISO 8601 timestamp when execution finished |
-| `num_of_steps` | `number` | Number of steps the agent took |
+Fetch a single run when you already know its `run_id`:
 
-**Throws:** `SDKError` if `run_id` is empty. `NotFoundError` if no run exists with that ID.
+```ts
+const run = await client.runs.get("run_abc123");
 
----
+console.log(run.status);
+console.log(run.result);
+console.log(run.streaming_url);
+```
 
-### `runs.list()` — list and filter runs
+Use `runs.list()` for filtering and pagination:
 
-List runs with optional filtering, sorting, and cursor-based pagination. All parameters are optional.
+```ts
+import { RunStatus, SortDirection, TinyFish } from "@tiny-fish/sdk";
 
-```typescript
-import { RunStatus, SortDirection } from "@tiny-fish/sdk";
+const client = new TinyFish();
 
 const response = await client.runs.list({
-  status: RunStatus.COMPLETED,                     // optional — filter by status
-  goal: "headlines",                               // optional — filter by goal text
-  created_after: "2025-01-01T00:00:00Z",           // optional — ISO 8601 lower bound
-  created_before: "2025-12-31T23:59:59Z",          // optional — ISO 8601 upper bound
-  sort_direction: SortDirection.DESC,               // optional — "asc" or "desc"
-  limit: 10,                                       // optional — max runs per page
-  cursor: undefined,                               // optional — pagination cursor from previous response
+  status: RunStatus.COMPLETED,
+  goal: "headlines",
+  sort_direction: SortDirection.DESC,
+  limit: 10,
 });
 
 for (const run of response.data) {
-  console.log(`${run.run_id} | ${run.goal}`);
+  console.log(`${run.run_id} | ${run.status} | ${run.goal}`);
 }
 
-// Pagination
 if (response.pagination.has_more) {
-  const nextPage = await client.runs.list({ cursor: response.pagination.next_cursor! });
+  const nextPage = await client.runs.list({
+    cursor: response.pagination.next_cursor ?? undefined,
+  });
+  console.log(`Fetched ${nextPage.data.length} more runs`);
 }
 ```
 
-**Returns `RunListResponse`:**
-
-| Field | Type | Description |
-|-------|------|-------------|
-| `data` | `Run[]` | List of runs |
-| `pagination.total` | `number` | Total runs matching filters |
-| `pagination.has_more` | `boolean` | Whether more pages exist |
-| `pagination.next_cursor` | `string \| null` | Pass to `cursor` for the next page |
-
-See the [Pagination Guide](docs/pagination-guide.md) for full pagination loop examples.
+### Query search
 
----
-
-### `search.query()` — run a web search
-
-Run a typed search query through the TinyFish Search API.
-
-```typescript
+```ts
 import { TinyFish } from "@tiny-fish/sdk";
 
 const client = new TinyFish();
@@ -406,96 +275,97 @@ console.log(response.total_results);
 console.log(response.results[0]?.title);
 ```
 
-**Returns `SearchQueryResponse`:**
+## Streaming events
+
+`agent.stream()` guarantees this event order:
 
-| Field | Type | Description |
-|-------|------|-------------|
-| `query` | `string` | The query that was executed |
-| `results` | `SearchResult[]` | Search results returned by the backend |
-| `total_results` | `number` | Total number of results returned |
+- `STARTED`
+- `STREAMING_URL`
+- `PROGRESS` repeated zero or more times
+- `COMPLETE`
 
-**Throws:** `SDKError` if `query` is empty. Standard API errors are handled by the shared SDK error hierarchy.
+`HEARTBEAT` events may also appear, but they are keepalive events rather than part of the guaranteed ordered sequence.
 
----
+You can consume the stream in two ways:
+
+- callbacks like `onProgress` and `onComplete`
+- direct iteration with `for await...of`
+
+To stop a stream early, call `await stream.close()`.
 
 ## Configuration
 
-### Client options
+```ts
+import { TinyFish } from "@tiny-fish/sdk";
 
-```typescript
 const client = new TinyFish({
-  apiKey: "your-api-key",                    // optional — or set TINYFISH_API_KEY env var
-  baseURL: "https://agent.tinyfish.ai",      // optional — default shown
-  timeout: 600_000,                          // optional — milliseconds (default: 600,000 = 10 min)
-  maxRetries: 2,                             // optional — retry attempts (default: 2)
+  apiKey: process.env.TINYFISH_API_KEY,
+  baseURL: "https://agent.tinyfish.ai",
+  timeout: 600_000,
+  maxRetries: 2,
 });
 ```
 
-The SDK retries `408`, `429`, and `5xx` errors automatically with exponential backoff (0.5s base, max 8s wait).
+Defaults:
 
-### Browser profiles
+- `baseURL`: `https://agent.tinyfish.ai`
+- `timeout`: `600000` ms
+- `maxRetries`: `2`
 
-Control the browser environment with `browser_profile`:
+The SDK automatically retries `408`, `429`, and `5xx` responses with exponential backoff. Authentication, validation, and not-found errors fail immediately.
 
-- **`lite`** (default) — fast, lightweight. Good for most sites.
-- **`stealth`** — anti-detection mode. Use for sites with bot protection.
+## Browser profiles and proxies
 
-```typescript
-import { BrowserProfile } from "@tiny-fish/sdk";
+`agent.run()`, `agent.queue()`, and `agent.stream()` all accept the same execution parameters:
 
-const response = await client.agent.run({
-  goal: "...",
-  url: "...",
-  browser_profile: BrowserProfile.STEALTH,
-});
-```
+- `goal` and `url` are required
+- `browser_profile` can be `BrowserProfile.LITE` or `BrowserProfile.STEALTH`
+- `proxy_config` can enable a proxy and optionally pin a country
 
-### Proxy configuration
+Supported proxy country codes:
 
-Route requests through a proxy, optionally pinned to a country:
-
-```typescript
-import { ProxyCountryCode } from "@tiny-fish/sdk";
-
-const response = await client.agent.run({
-  goal: "...",
-  url: "...",
-  proxy_config: { enabled: true, country_code: ProxyCountryCode.US },
-});
-```
-
-Available countries: `US`, `GB`, `CA`, `DE`, `FR`, `JP`, `AU`.
-
-See the [Proxy & Browser Profiles Guide](docs/proxy-and-browser-profiles.md) for more details.
+- `US`
+- `GB`
+- `CA`
+- `DE`
+- `FR`
+- `JP`
+- `AU`
 
 ## Error handling
 
-```typescript
-import { TinyFish, AuthenticationError, RateLimitError, SDKError } from "@tiny-fish/sdk";
+```ts
+import {
+  AuthenticationError,
+  RateLimitError,
+  SDKError,
+  TinyFish,
+} from "@tiny-fish/sdk";
 
 const client = new TinyFish();
 
 try {
-  const response = await client.agent.run({ goal: "...", url: "..." });
+  await client.agent.run({
+    goal: "Extract the page title",
+    url: "https://example.com",
+  });
 } catch (error) {
   if (error instanceof AuthenticationError) {
-    console.log("Invalid API key");
+    console.error("Invalid API key");
   } else if (error instanceof RateLimitError) {
-    console.log("Rate limited (retries exhausted)");
+    console.error("Rate limited");
   } else if (error instanceof SDKError) {
-    console.log("Something else went wrong");
+    console.error(error.message);
+  } else {
+    throw error;
   }
 }
 ```
 
-The SDK automatically retries transient errors (`408`, `429`, `5xx`) up to `maxRetries` times with exponential backoff. Non-retryable errors (`401`, `400`, `404`) throw immediately.
-
-For the full exception hierarchy and internal architecture, see [docs/internal/exceptions-and-errors-guide.md](docs/internal/exceptions-and-errors-guide.md).
-
 ## Guides
 
-- [Streaming Guide](docs/streaming-guide.md) — event lifecycle, callbacks vs iteration, event type reference
-- [Proxy & Browser Profiles](docs/proxy-and-browser-profiles.md) — stealth mode, proxy countries
-- [Pagination Guide](docs/pagination-guide.md) — filtering, sorting, cursor-based pagination
-- [Exceptions & Error Handling (internal)](docs/internal/exceptions-and-errors-guide.md) — layer-by-layer architecture
-- [Testing Guide](tests/testing-guide.md) — running and writing tests
+- [Streaming guide](https://github.com/tinyfish-io/ux-labs/blob/main/sdk/sdk-typescript/docs/streaming-guide.md)
+- [Pagination guide](https://github.com/tinyfish-io/ux-labs/blob/main/sdk/sdk-typescript/docs/pagination-guide.md)
+- [Proxy and browser profiles](https://github.com/tinyfish-io/ux-labs/blob/main/sdk/sdk-typescript/docs/proxy-and-browser-profiles.md)
+- [Error hierarchy and internals](https://github.com/tinyfish-io/ux-labs/blob/main/sdk/sdk-typescript/docs/internal/exceptions-and-errors-guide.md)
+- [Architecture notes for SDK contributors](https://github.com/tinyfish-io/ux-labs/blob/main/sdk/sdk-typescript/ARCHITECTURE.md)

package/dist/_utils/client.d.ts

@@ -43,8 +43,8 @@ export declare class BaseClient {
     private _parseErrorMessage;
     /** Maps HTTP status codes to typed error classes. Matches Python SDK's _make_status_error. */
     private _makeStatusError;
-    get<T>(path: string, options?: GetRequestOptions): Promise<T>;
-    post<T>(path: string, options?: PostRequestOptions): Promise<T>;
+    get<T = unknown>(path: string, options?: GetRequestOptions): Promise<T>;
+    post<T = unknown>(path: string, options?: PostRequestOptions): Promise<T>;
     postStream(path: string, options?: PostRequestOptions): Promise<ReadableStream<string>>;
 }
 export {};