4.0.1

fix:(exports)
BREAKING CHANGE(core): major architectural refactoring with cross-platform support and SmartRequest rename
2025-07-29 00:19:30 +00:00 · 2025-07-29 00:19:19 +00:00 · 2025-07-28 23:20:52 +00:00 · 2025-07-28 22:50:12 +00:00 · 2025-07-28 22:37:36 +00:00 · 2025-07-28 17:23:48 +00:00
38 changed files with 9433 additions and 7130 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,128 +0,0 @@
-# gitzone ci_default
-image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-
-cache:
-  paths:
-    - .npmci_cache/
-  key: '$CI_BUILD_STAGE'
-
-stages:
-  - security
-  - test
-  - release
-  - metadata
-
-before_script:
-  - npm install -g @shipzone/npmci
-
-# ====================
-# security stage
-# ====================
-auditProductionDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --production --ignore-scripts
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=prod --production
-  tags:
-    - docker
-  allow_failure: true
-
-auditDevDependencies:
-  image: registry.gitlab.com/hosttoday/ht-docker-node:npmci
-  stage: security
-  script:
-    - npmci npm prepare
-    - npmci command npm install --ignore-scripts
-    - npmci command npm config set registry https://registry.npmjs.org
-    - npmci command npm audit --audit-level=high --only=dev
-  tags:
-    - docker
-  allow_failure: true
-
-# ====================
-# test stage
-# ====================
-
-testStable:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-testBuild:
-  stage: test
-  script:
-    - npmci npm prepare
-    - npmci node install stable
-    - npmci npm install
-    - npmci command npm run build
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-    - docker
-
-release:
-  stage: release
-  script:
-    - npmci node install stable
-    - npmci npm publish
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-# ====================
-# metadata stage
-# ====================
-codequality:
-  stage: metadata
-  allow_failure: true
-  only:
-    - tags
-  script:
-    - npmci command npm install -g typescript
-    - npmci npm prepare
-    - npmci npm install
-  tags:
-    - lossless
-    - docker
-    - priv
-
-trigger:
-  stage: metadata
-  script:
-    - npmci trigger
-  only:
-    - tags
-  tags:
-    - lossless
-    - docker
-    - notpriv
-
-pages:
-  stage: metadata
-  script:
-    - npmci node install stable 
-    - npmci npm prepare
-    - npmci npm install
-    - npmci command npm run buildDocs
-  tags:
-    - lossless
-    - docker
-    - notpriv
-  only:
-    - tags
-  artifacts:
-    expire_in: 1 week
-    paths:
-      - public
-  allow_failure: true
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,70 @@
 # Changelog

+## 2025-07-28 - 4.0.0 - BREAKING CHANGE(core)
+Complete architectural overhaul with cross-platform support
+
+**Breaking Changes:**
+- Renamed `SmartRequestClient` to `SmartRequest` for simpler, cleaner API
+- Removed legacy API entirely (no more `/legacy` import path)
+- Major architectural refactoring:
+  - Added abstraction layer with `core_base` containing abstract classes
+  - Split implementations into `core_node` (Node.js) and `core_fetch` (browser)
+  - Dynamic implementation selection based on environment
+- Response streaming API changes:
+  - `stream()` now always returns web-style `ReadableStream<Uint8Array>`
+  - Added `streamNode()` for Node.js streams (throws error in browser)
+- Unified type system with single `ICoreRequestOptions` interface
+- Removed all "Abstract" prefixes from type names
+
+**Features:**
+- Full cross-platform support (Node.js and browsers)
+- Automatic platform detection using @push.rocks/smartenv
+- Consistent API across platforms with platform-specific capabilities
+- Web Streams API support in both environments
+- Better error messages for unsupported platform features
+
+**Documentation:**
+- Completely rewritten README with platform-specific examples
+- Added architecture overview section
+- Added migration guide from v2.x and v3.x
+- Updated all examples to use the new `SmartRequest` class name
+
+## 2025-07-27 - 3.0.0 - BREAKING CHANGE(core)
+Major architectural refactoring with fetch-like API
+
+**Breaking Changes:**
+- Legacy API functions are now imported from `@push.rocks/smartrequest/legacy` instead of the main export
+- Modern API response objects now use fetch-like methods (`.json()`, `.text()`, `.arrayBuffer()`, `.stream()`) instead of direct `.body` access
+- Renamed `responseType()` method to `accept()` in modern API
+- Removed automatic defaults:
+  - No default keepAlive (must be explicitly set)
+  - No default timeouts
+  - No automatic JSON parsing in core
+- Complete internal architecture refactoring:
+  - Core module now always returns raw streams
+  - Response parsing happens in SmartResponse methods
+  - Legacy API is now just an adapter over the core module
+
+**Features:**
+- New fetch-like response API with single-use body consumption
+- Better TypeScript support and type safety
+- Cleaner separation of concerns between request and response
+- More predictable behavior aligned with fetch API standards
+
+**Documentation:**
+- Updated all examples to show correct import paths
+- Added comprehensive examples for the new response API
+- Enhanced migration guide
+
+## 2025-04-03 - 2.1.0 - feat(docs)
+Enhance documentation and tests with modern API usage examples and migration guide
+
+- Updated README to include detailed examples for the modern fluent API, covering GET, POST, headers, query, timeout, retries, and pagination
+- Added a migration guide comparing the legacy API and modern API usage
+- Improved installation instructions with npm, pnpm, and yarn examples
+- Added and updated test files for both legacy and modern API functionalities
+- Minor formatting improvements in the code and documentation examples
+
 ## 2024-11-06 - 2.0.23 - fix(core)
 Enhance type safety for response in binary requests

--- a/package.json
+++ b/package.json
@@ -1,13 +1,16 @@
 {
  "name": "@push.rocks/smartrequest",
-  "version": "2.0.23",
+  "version": "4.0.1",
  "private": false,
  "description": "A module for modern HTTP/HTTPS requests with support for form data, file uploads, JSON, binary data, streams, and more.",
-  "main": "dist_ts/index.js",
-  "typings": "dist_ts/index.d.ts",
+  "exports": {
+    ".": "./dist_ts/index.js",
+    "./core_node": "./dist_ts/core_node/index.js",
+    "./core_fetch": "./dist_ts/core_fetch/index.js"
+  },
  "type": "module",
  "scripts": {
-    "test": "(tstest test/ --web)",
+    "test": "(tstest test/ --verbose)",
    "build": "(tsbuild --web)",
    "buildDocs": "tsdoc"
  },
@@ -29,23 +32,24 @@
    "modern web requests",
    "drop-in replacement"
  ],
-  "author": "Lossless GmbH",
+  "author": "Task Venture Capital GmbH",
  "license": "MIT",
  "bugs": {
    "url": "https://gitlab.com/push.rocks/smartrequest/issues"
  },
  "homepage": "https://code.foss.global/push.rocks/smartrequest",
  "dependencies": {
+    "@push.rocks/smartenv": "^5.0.13",
+    "@push.rocks/smartpath": "^6.0.0",
    "@push.rocks/smartpromise": "^4.0.4",
    "@push.rocks/smarturl": "^3.1.0",
    "agentkeepalive": "^4.5.0",
-    "form-data": "^4.0.1"
+    "form-data": "^4.0.4"
  },
  "devDependencies": {
-    "@git.zone/tsbuild": "^2.2.0",
+    "@git.zone/tsbuild": "^2.6.4",
    "@git.zone/tsrun": "^1.3.3",
-    "@git.zone/tstest": "^1.0.90",
-    "@pushrocks/tapbundle": "^5.0.8",
+    "@git.zone/tstest": "^2.3.2",
    "@types/node": "^22.9.0"
  },
  "files": [
@@ -62,5 +66,6 @@
  ],
  "browserslist": [
    "last 1 chrome versions"
-  ]
+  ],
+  "packageManager": "pnpm@10.7.0+sha512.6b865ad4b62a1d9842b61d674a393903b871d9244954f652b8842c2b553c72176b278f64c463e52d40fff8aba385c235c8c9ecf5cc7de4fd78b8bb6d49633ab6"
 }
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
--- a/readme.hints.md
+++ b/readme.hints.md
@@ -1,3 +1,6 @@
+# SmartRequest Architecture Hints
+
+## Core Features
 - supports http
 - supports https  
 - supports unix socks
@@ -8,4 +11,69 @@
 - written in TypeScript
 - continuously updated
 - uses node native http and https modules
+- supports both Node.js and browser environments
 - used in modules like @push.rocks/smartproxy and @api.global/typedrequest
+
+## Architecture Overview (as of v3.0.0 major refactoring)
+- The project now has a multi-layer architecture with platform abstraction
+- Base layer (ts/core_base/) contains abstract classes and unified types
+- Node.js implementation (ts/core_node/) uses native http/https modules
+- Fetch implementation (ts/core_fetch/) uses Fetch API for browser compatibility
+- Core module (ts/core/) dynamically selects the appropriate implementation based on environment
+- Client API (ts/client/) provides a fluent, chainable interface  
+- Legacy API has been completely removed in v3.0.0
+
+## Key Components
+
+### Core Base Module (ts/core_base/)
+- `request.ts`: Abstract CoreRequest class defining the request interface
+- `response.ts`: Abstract CoreResponse class with fetch-like API
+  - Defines `stream()` method that always returns web-style ReadableStream
+  - Body can only be consumed once (throws error on second attempt)
+- `types.ts`: Unified TypeScript interfaces and types
+  - Single `ICoreRequestOptions` interface for all implementations
+  - Implementations handle unsupported options by throwing errors
+
+### Core Node Module (ts/core_node/)
+- `request.ts`: Node.js implementation using http/https modules
+  - Supports unix socket connections and keep-alive agents
+  - Converts Node.js specific options from unified interface
+- `response.ts`: Node.js CoreResponse implementation
+  - `stream()` method converts Node.js stream to web ReadableStream
+  - `streamNode()` method returns native Node.js stream
+  - Methods like `json()`, `text()`, `arrayBuffer()` handle parsing
+
+### Core Fetch Module (ts/core_fetch/)
+- `request.ts`: Fetch API implementation for browsers
+  - Throws errors for Node.js specific options (agent, socketPath)
+  - Native support for CORS, credentials, and other browser features
+- `response.ts`: Fetch-based CoreResponse implementation
+  - `stream()` returns native web ReadableStream from response.body
+  - `streamNode()` throws error explaining it's not available in browser
+
+### Core Module (ts/core/)
+- Dynamically loads appropriate implementation based on environment
+- Uses @push.rocks/smartenv for environment detection
+- Exports unified types from core_base
+
+### Client API (ts/client/)
+- SmartRequest: Fluent API with method chaining
+- Returns CoreResponse objects with fetch-like methods
+- Supports pagination, retries, timeouts, and various response types
+
+### Stream Handling
+- `stream()` method always returns web-style ReadableStream<Uint8Array>
+- In Node.js, converts native streams to web streams
+- `streamNode()` available only in Node.js environment for native streams
+- Consistent API across platforms while preserving platform-specific capabilities
+
+### Binary Request Handling
+- Binary requests handled through ArrayBuffer API
+- Response body kept as Buffer/ArrayBuffer without string conversion
+- No automatic transformations applied to binary data
+
+## Testing
+- Use `pnpm test` to run all tests
+- Tests use @git.zone/tstest/tapbundle for assertions
+- Separate test files for Node.js (test.node.ts) and browser (test.browser.ts)
+- Browser tests run in headless Chromium via puppeteer
--- a/readme.md
+++ b/readme.md
@@ -1,123 +1,497 @@
 # @push.rocks/smartrequest
-A module providing a drop-in replacement for the deprecated Request library, focusing on modern HTTP/HTTPS requests with support for form data, file uploads, JSON, binary data, and streams.
+A modern, cross-platform HTTP/HTTPS request library for Node.js and browsers with a unified API, supporting form data, file uploads, JSON, binary data, streams, and unix sockets.

 ## Install
-To install `@push.rocks/smartrequest`, use the following npm command:
-
 ```bash
+# Using npm
 npm install @push.rocks/smartrequest --save
+
+# Using pnpm  
+pnpm add @push.rocks/smartrequest
+
+# Using yarn
+yarn add @push.rocks/smartrequest
 ```

-This command will add `@push.rocks/smartrequest` to your project's dependencies.
+## Key Features
+
+- 🚀 **Modern Fetch-like API** - Familiar response methods (`.json()`, `.text()`, `.arrayBuffer()`, `.stream()`)
+- 🌐 **Cross-Platform** - Works in both Node.js and browsers with a unified API
+- 🔌 **Unix Socket Support** - Connect to local services like Docker (Node.js only)
+- 📦 **Form Data & File Uploads** - Built-in support for multipart/form-data
+- 🔁 **Pagination Support** - Multiple strategies (offset, cursor, Link headers)
+- ⚡ **Keep-Alive Connections** - Efficient connection pooling in Node.js
+- 🛡️ **TypeScript First** - Full type safety and IntelliSense support
+- 🎯 **Zero Magic Defaults** - Explicit configuration following fetch API principles
+- 📡 **Streaming Support** - Handle large files and real-time data
+- 🔧 **Highly Configurable** - Timeouts, retries, headers, and more
+
+## Architecture
+
+SmartRequest v3.0 features a multi-layer architecture that provides consistent behavior across platforms:
+
+- **Core Base** - Abstract classes and unified types shared across implementations
+- **Core Node** - Node.js implementation using native http/https modules
+- **Core Fetch** - Browser implementation using the Fetch API
+- **Core** - Dynamic implementation selection based on environment
+- **Client** - High-level fluent API for everyday use

 ## Usage
-`@push.rocks/smartrequest` is designed as a versatile, modern HTTP client library for making HTTP/HTTPS requests. It supports a range of features, including handling form data, file uploads, JSON requests, binary data, streaming, and much more, all within a modern, promise-based API.

-Below we will cover key usage scenarios of `@push.rocks/smartrequest`, showcasing its capabilities and providing you with a solid starting point to integrate it into your projects.
+`@push.rocks/smartrequest` provides a clean, type-safe API inspired by the native fetch API but with additional features needed for modern applications.

-### Simple GET Request
-
-For fetching data from a REST API or any web service that returns JSON:
+### Basic Usage

 ```typescript
-import { getJson } from '@push.rocks/smartrequest';
+import { SmartRequest } from '@push.rocks/smartrequest';

-async function fetchGitHubUserInfo(username: string) {
-  const response = await getJson(`https://api.github.com/users/${username}`);
-  console.log(response.body); // The body contains the JSON response
+// Simple GET request
+async function fetchUserData(userId: number) {
+  const response = await SmartRequest.create()
+    .url(`https://jsonplaceholder.typicode.com/users/${userId}`)
+    .get();
+
+  // Use the fetch-like response API
+  const userData = await response.json();
+  console.log(userData); // The parsed JSON response
 }

-fetchGitHubUserInfo('octocat');
-```
+// POST request with JSON body
+async function createPost(title: string, body: string, userId: number) {
+  const response = await SmartRequest.create()
+    .url('https://jsonplaceholder.typicode.com/posts')
+    .json({ title, body, userId })
+    .post();

-The `getJson` function simplifies the process of sending a GET request and parsing the JSON response.
-
-### POST Requests with JSON
-
-When you need to send JSON data to a server, for example, creating a new resource:
-
-```typescript
-import { postJson } from '@push.rocks/smartrequest';
-
-async function createTodoItem(todoDetails: { title: string; completed: boolean }) {
-  const response = await postJson('https://jsonplaceholder.typicode.com/todos', {
-    requestBody: todoDetails
-  });
-  console.log(response.body); // Log the created todo item
+  const createdPost = await response.json();
+  console.log(createdPost); // The created post
 }
-
-createTodoItem({ title: 'Implement smartrequest', completed: false });
 ```

-`postJson` handles setting the appropriate content-type header and stringifies the JSON body.
+### Direct Core API Usage

-### Handling Form Data and File Uploads
-
-`@push.rocks/smartrequest` simplifies the process of uploading files and submitting form data to a server:
+For advanced use cases, you can use the Core API directly:

 ```typescript
-import { postFormData, IFormField } from '@push.rocks/smartrequest';
+import { CoreRequest } from '@push.rocks/smartrequest';

-async function uploadProfilePicture(formDataFields: IFormField[]) {
-  await postFormData('https://api.example.com/upload', {}, formDataFields);
-}
-
-uploadProfilePicture([
-  { name: 'avatar', type: 'filePath', payload: './path/to/avatar.jpg', fileName: 'avatar.jpg', contentType: 'image/jpeg' },
-  { name: 'user_id', type: 'string', payload: '12345' }
-]);
-```
-
-### Streaming Support
-
-For cases when dealing with large datasets or streaming APIs, `@push.rocks/smartrequest` provides streaming capabilities:
-
-```typescript
-import { getStream } from '@push.rocks/smartrequest';
-
-async function streamLargeFile(url: string) {
-  const stream = await getStream(url);
-
-  stream.on('data', (chunk) => {
-    console.log('Received chunk of data.');
-  });
-
-  stream.on('end', () => {
-    console.log('Stream ended.');
-  });
-}
-
-streamLargeFile('https://example.com/largefile');
-```
-
-`getStream` allows you to handle data as it's received, which can be beneficial for performance and scalability.
-
-### Advanced Options and Customization
-
-`@push.rocks/smartrequest` is built to be flexible, allowing you to specify additional options to tailor requests to your needs:
-
-```typescript
-import { request, ISmartRequestOptions } from '@push.rocks/smartrequest';
-
-async function customRequestExample() {
-  const options: ISmartRequestOptions = {
+async function directCoreRequest() {
+  const request = new CoreRequest('https://api.example.com/data', {
    method: 'GET',
    headers: {
-      'Custom-Header': 'Value'
-    },
-    keepAlive: true // Enables connection keep-alive
-  };
-
-  const response = await request('https://example.com/data', options);
-  console.log(response.body);
+      'Accept': 'application/json'
    }
+  });
  
-customRequestExample();
+  const response = await request.fire();
+  const data = await response.json();
+  return data;
+}
 ```

-`request` is the underlying function that powers the simpler `getJson`, `postJson`, etc., and provides you with full control over the HTTP request.
+### Setting Headers and Query Parameters

-Through its comprehensive set of features tailored for modern web development, `@push.rocks/smartrequest` aims to provide developers with a powerful tool for handling HTTP/HTTPS requests efficiently. Whether it's a simple API call, handling form data, or processing streams, `@push.rocks/smartrequest` delivers a robust, type-safe solution to fit your project's requirements.
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+async function searchRepositories(query: string, perPage: number = 10) {
+  const response = await SmartRequest.create()
+    .url('https://api.github.com/search/repositories')
+    .header('Accept', 'application/vnd.github.v3+json')
+    .query({
+      q: query,
+      per_page: perPage.toString()
+    })
+    .get();
+
+  const data = await response.json();
+  return data.items;
+}
+```
+
+### Handling Timeouts and Retries
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+async function fetchWithRetry(url: string) {
+  const response = await SmartRequest.create()
+    .url(url)
+    .timeout(5000) // 5 seconds timeout
+    .retry(3) // Retry up to 3 times on failure
+    .get();
+
+  return await response.json();
+}
+```
+
+### Working with Different Response Types
+
+The API provides a fetch-like interface for handling different response types:
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+// JSON response (default)
+async function fetchJson(url: string) {
+  const response = await SmartRequest.create()
+    .url(url)
+    .get();
+  
+  return await response.json(); // Parses JSON automatically
+}
+
+// Text response
+async function fetchText(url: string) {
+  const response = await SmartRequest.create()
+    .url(url)
+    .get();
+  
+  return await response.text(); // Returns response as string
+}
+
+// Binary data
+async function downloadImage(url: string) {
+  const response = await SmartRequest.create()
+    .url(url)
+    .accept('binary') // Optional: hints to server we want binary
+    .get();
+
+  const buffer = await response.arrayBuffer();
+  return Buffer.from(buffer); // Convert ArrayBuffer to Buffer if needed
+}
+
+// Streaming response (Web Streams API)
+async function streamLargeFile(url: string) {
+  const response = await SmartRequest.create()
+    .url(url)
+    .get();
+
+  // Get a web-style ReadableStream (works in both Node.js and browsers)
+  const stream = response.stream();
+  
+  if (stream) {
+    const reader = stream.getReader();
+    
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        console.log(`Received ${value.length} bytes of data`);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  }
+}
+
+// Node.js specific stream (only in Node.js environment)
+async function streamWithNodeApi(url: string) {
+  const response = await SmartRequest.create()
+    .url(url)
+    .get();
+
+  // Only available in Node.js, throws error in browser
+  const nodeStream = response.streamNode();
+  
+  nodeStream.on('data', (chunk) => {
+    console.log(`Received ${chunk.length} bytes of data`);
+  });
+
+  return new Promise((resolve, reject) => {
+    nodeStream.on('end', resolve);
+    nodeStream.on('error', reject);
+  });
+}
+```
+
+### Response Object Methods
+
+The response object provides these methods:
+
+- `json<T>(): Promise<T>` - Parse response as JSON
+- `text(): Promise<string>` - Get response as text
+- `arrayBuffer(): Promise<ArrayBuffer>` - Get response as ArrayBuffer
+- `stream(): ReadableStream<Uint8Array> | null` - Get web-style ReadableStream (cross-platform)
+- `streamNode(): NodeJS.ReadableStream` - Get Node.js stream (Node.js only, throws in browser)
+- `raw(): Response | http.IncomingMessage` - Get the underlying platform response
+
+Each body method can only be called once per response, similar to the fetch API.
+
+## Advanced Features
+
+### Form Data with File Uploads
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+import * as fs from 'fs';
+
+async function uploadMultipleFiles(files: Array<{name: string, path: string}>) {
+  const formFields = files.map(file => ({
+    name: 'files',
+    value: fs.readFileSync(file.path),
+    filename: file.name,
+    contentType: 'application/octet-stream'
+  }));
+
+  const response = await SmartRequest.create()
+    .url('https://api.example.com/upload')
+    .formData(formFields)
+    .post();
+  
+  return await response.json();
+}
+```
+
+### Unix Socket Support (Node.js only)
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+// Connect to a service via Unix socket
+async function queryViaUnixSocket() {
+  const response = await SmartRequest.create()
+    .url('http://unix:/var/run/docker.sock:/v1.24/containers/json')
+    .get();
+  
+  return await response.json();
+}
+```
+
+### Pagination Support
+
+The library includes built-in support for various pagination strategies:
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+// Offset-based pagination (page & limit)
+async function fetchAllUsers() {
+  const client = SmartRequest.create()
+    .url('https://api.example.com/users')
+    .withOffsetPagination({
+      pageParam: 'page',
+      limitParam: 'limit',
+      startPage: 1,
+      pageSize: 20,
+      totalPath: 'meta.total'
+    });
+
+  // Get first page with pagination info
+  const firstPage = await client.getPaginated();
+  console.log(`Found ${firstPage.items.length} users on first page`);
+  console.log(`Has more pages: ${firstPage.hasNextPage}`);
+
+  if (firstPage.hasNextPage) {
+    // Get next page
+    const secondPage = await firstPage.getNextPage();
+    console.log(`Found ${secondPage.items.length} more users`);
+  }
+
+  // Or get all pages at once (use with caution for large datasets)
+  const allUsers = await client.getAllPages();
+  console.log(`Retrieved ${allUsers.length} users in total`);
+}
+
+// Cursor-based pagination
+async function fetchAllPosts() {
+  const allPosts = await SmartRequest.create()
+    .url('https://api.example.com/posts')
+    .withCursorPagination({
+      cursorParam: 'cursor',
+      cursorPath: 'meta.nextCursor',
+      hasMorePath: 'meta.hasMore'
+    })
+    .getAllPages();
+
+  console.log(`Retrieved ${allPosts.length} posts in total`);
+}
+
+// Link header-based pagination (GitHub API style)
+async function fetchAllIssues(repo: string) {
+  const paginatedResponse = await SmartRequest.create()
+    .url(`https://api.github.com/repos/${repo}/issues`)
+    .header('Accept', 'application/vnd.github.v3+json')
+    .withLinkPagination()
+    .getPaginated();
+
+  return paginatedResponse.getAllPages();
+}
+```
+
+### Keep-Alive Connections (Node.js)
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+// Enable keep-alive for better performance with multiple requests
+async function performMultipleRequests() {
+  const client = SmartRequest.create()
+    .header('Connection', 'keep-alive');
+
+  // Requests will reuse the same connection in Node.js
+  const results = await Promise.all([
+    client.url('https://api.example.com/endpoint1').get(),
+    client.url('https://api.example.com/endpoint2').get(),
+    client.url('https://api.example.com/endpoint3').get()
+  ]);
+
+  return Promise.all(results.map(r => r.json()));
+}
+```
+
+## Platform-Specific Features
+
+### Browser-Specific Options
+
+When running in a browser, you can use browser-specific fetch options:
+
+```typescript
+const response = await SmartRequest.create()
+  .url('https://api.example.com/data')
+  .option({
+    credentials: 'include', // Include cookies
+    mode: 'cors',          // CORS mode
+    cache: 'no-cache',     // Cache mode
+    referrerPolicy: 'no-referrer'
+  })
+  .get();
+```
+
+### Node.js-Specific Options
+
+When running in Node.js, you can use Node-specific options:
+
+```typescript
+import { Agent } from 'https';
+
+const response = await SmartRequest.create()
+  .url('https://api.example.com/data')
+  .option({
+    agent: new Agent({ keepAlive: true }), // Custom agent
+    socketPath: '/var/run/api.sock',       // Unix socket
+  })
+  .get();
+```
+
+## Complete Example: Building a REST API Client
+
+Here's a complete example of building a typed API client:
+
+```typescript
+import { SmartRequest, type CoreResponse } from '@push.rocks/smartrequest';
+
+interface User {
+  id: number;
+  name: string;
+  email: string;
+}
+
+interface Post {
+  id: number;
+  title: string;
+  body: string;
+  userId: number;
+}
+
+class BlogApiClient {
+  private baseUrl = 'https://jsonplaceholder.typicode.com';
+  
+  private async request(path: string) {
+    return SmartRequest.create()
+      .url(`${this.baseUrl}${path}`)
+      .header('Accept', 'application/json');
+  }
+  
+  async getUser(id: number): Promise<User> {
+    const response = await this.request(`/users/${id}`).get();
+    return response.json<User>();
+  }
+  
+  async createPost(post: Omit<Post, 'id'>): Promise<Post> {
+    const response = await this.request('/posts')
+      .json(post)
+      .post();
+    return response.json<Post>();
+  }
+  
+  async deletePost(id: number): Promise<void> {
+    const response = await this.request(`/posts/${id}`).delete();
+    
+    if (!response.ok) {
+      throw new Error(`Failed to delete post: ${response.statusText}`);
+    }
+  }
+  
+  async getAllPosts(userId?: number): Promise<Post[]> {
+    const client = this.request('/posts');
+    
+    if (userId) {
+      client.query({ userId: userId.toString() });
+    }
+    
+    const response = await client.get();
+    return response.json<Post[]>();
+  }
+}
+
+// Usage
+const api = new BlogApiClient();
+const user = await api.getUser(1);
+const posts = await api.getAllPosts(user.id);
+```
+
+## Error Handling
+
+```typescript
+import { SmartRequest } from '@push.rocks/smartrequest';
+
+async function fetchWithErrorHandling(url: string) {
+  try {
+    const response = await SmartRequest.create()
+      .url(url)
+      .timeout(5000)
+      .retry(2)
+      .get();
+    
+    // Check if request was successful
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    
+    // Handle different content types
+    const contentType = response.headers['content-type'];
+    
+    if (contentType?.includes('application/json')) {
+      return await response.json();
+    } else if (contentType?.includes('text/')) {
+      return await response.text();
+    } else {
+      return await response.arrayBuffer();
+    }
+  } catch (error) {
+    if (error.code === 'ECONNREFUSED') {
+      console.error('Connection refused - is the server running?');
+    } else if (error.code === 'ETIMEDOUT') {
+      console.error('Request timed out');
+    } else if (error.name === 'AbortError') {
+      console.error('Request was aborted');
+    } else {
+      console.error('Request failed:', error.message);
+    }
+    throw error;
+  }
+}
+```
+
+## Migrating from v2.x to v3.x
+
+Version 3.0 brings significant architectural improvements and a more consistent API:
+
+1. **Legacy API Removed**: The function-based API (getJson, postJson, etc.) has been removed. Use SmartRequest instead.
+2. **Unified Response API**: All responses now use the same fetch-like interface regardless of platform.
+3. **Stream Changes**: The `stream()` method now returns a web-style ReadableStream on all platforms. Use `streamNode()` for Node.js streams.
+4. **Cross-Platform by Default**: The library now works in browsers out of the box with automatic platform detection.

 ## License and Legal Information

--- a/test/test.browser.ts
+++ b/test/test.browser.ts
@@ -0,0 +1,102 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+
+// For browser tests, we need to import from a browser-safe path
+// that doesn't trigger Node.js module imports
+import { CoreRequest, CoreResponse } from '../ts/core/index.js';
+import type { ICoreRequestOptions } from '../ts/core_base/types.js';
+
+tap.test('browser: should request a JSON document over https', async () => {
+  const request = new CoreRequest('https://jsonplaceholder.typicode.com/posts/1');
+  const response = await request.fire();
+
+  expect(response).not.toBeNull();
+  expect(response).toHaveProperty('status');
+  expect(response.status).toEqual(200);
+  
+  const data = await response.json();
+  expect(data).toHaveProperty('id');
+  expect(data.id).toEqual(1);
+  expect(data).toHaveProperty('title');
+});
+
+tap.test('browser: should handle CORS requests', async () => {
+  const options: ICoreRequestOptions = {
+    headers: {
+      'Accept': 'application/vnd.github.v3+json'
+    }
+  };
+  
+  const request = new CoreRequest('https://api.github.com/users/github', options);
+  const response = await request.fire();
+
+  expect(response).not.toBeNull();
+  expect(response.status).toEqual(200);
+  
+  const data = await response.json();
+  expect(data).toHaveProperty('login');
+  expect(data.login).toEqual('github');
+});
+
+tap.test('browser: should handle request timeouts', async () => {
+  let timedOut = false;
+  
+  const options: ICoreRequestOptions = {
+    timeout: 1000
+  };
+  
+  try {
+    const request = new CoreRequest('https://httpbin.org/delay/10', options);
+    await request.fire();
+  } catch (error) {
+    timedOut = true;
+    expect(error.message).toContain('timed out');
+  }
+  
+  expect(timedOut).toEqual(true);
+});
+
+tap.test('browser: should handle POST requests with JSON', async () => {
+  const testData = {
+    title: 'foo',
+    body: 'bar',
+    userId: 1
+  };
+  
+  const options: ICoreRequestOptions = {
+    method: 'POST',
+    requestBody: testData
+  };
+  
+  const request = new CoreRequest('https://jsonplaceholder.typicode.com/posts', options);
+  const response = await request.fire();
+    
+  expect(response.status).toEqual(201);
+  
+  const responseData = await response.json();
+  expect(responseData).toHaveProperty('id');
+  expect(responseData.title).toEqual(testData.title);
+  expect(responseData.body).toEqual(testData.body);
+  expect(responseData.userId).toEqual(testData.userId);
+});
+
+tap.test('browser: should handle query parameters', async () => {
+  const options: ICoreRequestOptions = {
+    queryParams: {
+      foo: 'bar',
+      baz: 'qux'
+    }
+  };
+  
+  const request = new CoreRequest('https://httpbin.org/get', options);
+  const response = await request.fire();
+    
+  expect(response.status).toEqual(200);
+  
+  const data = await response.json();
+  expect(data.args).toHaveProperty('foo');
+  expect(data.args.foo).toEqual('bar');
+  expect(data.args).toHaveProperty('baz');
+  expect(data.args.baz).toEqual('qux');
+});
+
+export default tap.start();
--- a/test/test.node.ts
+++ b/test/test.node.ts
@@ -0,0 +1,95 @@
+import { tap, expect } from '@git.zone/tstest/tapbundle';
+
+import { SmartRequest } from '../ts/client/index.js';
+
+tap.test('client: should request a html document over https', async () => {
+  const response = await SmartRequest.create()
+    .url('https://encrypted.google.com/')
+    .get();
+
+  expect(response).not.toBeNull();
+  expect(response).toHaveProperty('status');
+  expect(response.status).toBeGreaterThan(0);
+  const text = await response.text();
+  expect(text.length).toBeGreaterThan(0);
+});
+
+tap.test('client: should request a JSON document over https', async () => {
+  const response = await SmartRequest.create()
+    .url('https://jsonplaceholder.typicode.com/posts/1')
+    .get();
+
+  const body = await response.json();
+  expect(body).toHaveProperty('id');
+  expect(body.id).toEqual(1);
+});
+
+tap.test('client: should post a JSON document over http', async () => {
+  const testData = { text: 'example_text' };
+  const response = await SmartRequest.create()
+    .url('https://httpbin.org/post')
+    .json(testData)
+    .post();
+
+  const body = await response.json();
+  expect(body).toHaveProperty('json');
+  expect(body.json).toHaveProperty('text');
+  expect(body.json.text).toEqual('example_text');
+});
+
+tap.test('client: should set headers correctly', async () => {
+  const customHeader = 'X-Custom-Header';
+  const headerValue = 'test-value';
+
+  const response = await SmartRequest.create()
+    .url('https://httpbin.org/headers')
+    .header(customHeader, headerValue)
+    .get();
+
+  const body = await response.json();
+  expect(body).toHaveProperty('headers');
+
+  // Check if the header exists (case-sensitive)
+  expect(body.headers).toHaveProperty(customHeader);
+  expect(body.headers[customHeader]).toEqual(headerValue);
+});
+
+tap.test('client: should handle query parameters', async () => {
+  const params = { param1: 'value1', param2: 'value2' };
+
+  const response = await SmartRequest.create()
+    .url('https://httpbin.org/get')
+    .query(params)
+    .get();
+
+  const body = await response.json();
+  expect(body).toHaveProperty('args');
+  expect(body.args).toHaveProperty('param1');
+  expect(body.args.param1).toEqual('value1');
+  expect(body.args).toHaveProperty('param2');
+  expect(body.args.param2).toEqual('value2');
+});
+
+tap.test('client: should handle timeout configuration', async () => {
+  // This test just verifies that the timeout method doesn't throw
+  const client = SmartRequest.create()
+    .url('https://httpbin.org/get')
+    .timeout(5000);
+
+  const response = await client.get();
+  expect(response).toHaveProperty('ok');
+  expect(response.ok).toBeTrue();
+});
+
+tap.test('client: should handle retry configuration', async () => {
+  // This test just verifies that the retry method doesn't throw
+  const client = SmartRequest.create()
+    .url('https://httpbin.org/get')
+    .retry(1);
+
+  const response = await client.get();
+  expect(response).toHaveProperty('ok');
+  expect(response.ok).toBeTrue();
+});
+
+tap.start();
--- a/test/test.ts
+++ b/test/test.ts
@@ -1,43 +0,0 @@
-import { tap, expect, expectAsync } from '@pushrocks/tapbundle';
-
-import * as smartrequest from '../ts/index.js';
-
-tap.test('should request a html document over https', async () => {
-  await expectAsync(smartrequest.getJson('https://encrypted.google.com/')).toHaveProperty('body');
-});
-
-tap.test('should request a JSON document over https', async () => {
-  await expectAsync(smartrequest.getJson('https://jsonplaceholder.typicode.com/posts/1'))
-    .property('body')
-    .property('id')
-    .toEqual(1);
-});
-
-tap.test('should post a JSON document over http', async () => {
-  await expectAsync(smartrequest.postJson('http://md5.jsontest.com/?text=example_text'))
-    .property('body')
-    .property('md5')
-    .toEqual('fa4c6baa0812e5b5c80ed8885e55a8a6');
-});
-
-tap.test('should safe get stuff', async () => {
-  smartrequest.safeGet('http://coffee.link/');
-  smartrequest.safeGet('https://coffee.link/');
-});
-
-tap.skip.test('should deal with unix socks', async () => {
-  const socketResponse = await smartrequest.request(
-    'http://unix:/var/run/docker.sock:/containers/json',
-    {
-      headers: {
-        'Content-Type': 'application/json',
-        Host: 'docker.sock',
-      },
-    }
-  );
-  console.log(socketResponse.body);
-});
-
-tap.skip.test('should correctly upload a file using formData', async () => {});
-
-tap.start();
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -3,6 +3,6 @@
 */
 export const commitinfo = {
  name: '@push.rocks/smartrequest',
-  version: '2.0.23',
+  version: '2.1.0',
  description: 'A module for modern HTTP/HTTPS requests with support for form data, file uploads, JSON, binary data, streams, and more.'
 }
--- a/ts/client/features/pagination.ts
+++ b/ts/client/features/pagination.ts
@@ -0,0 +1,176 @@
+import { type CoreResponse } from '../../core/index.js';
+import type { ICoreResponse } from '../../core_base/types.js';
+import { type TPaginationConfig, PaginationStrategy, type TPaginatedResponse } from '../types/pagination.js';
+
+/**
+ * Creates a paginated response from a regular response
+ */
+export async function createPaginatedResponse<T>(
+  response: ICoreResponse<any>,
+  paginationConfig: TPaginationConfig,
+  queryParams: Record<string, string>,
+  fetchNextPage: (params: Record<string, string>) => Promise<TPaginatedResponse<T>>
+): Promise<TPaginatedResponse<T>> {
+  // Parse response body first
+  const body = await response.json() as any;
+  
+  // Default to response.body for items if response is JSON
+  let items: T[] = Array.isArray(body)
+    ? body
+    : (body?.items || body?.data || body?.results || []);
+
+  let hasNextPage = false;
+  let nextPageParams: Record<string, string> = {};
+
+  // Determine if there's a next page based on pagination strategy
+  switch (paginationConfig.strategy) {
+    case PaginationStrategy.OFFSET: {
+      const config = paginationConfig;
+      const currentPage = parseInt(queryParams[config.pageParam || 'page'] || String(config.startPage || 1));
+      const limit = parseInt(queryParams[config.limitParam || 'limit'] || String(config.pageSize || 20));
+      const total = getValueByPath(body, config.totalPath || 'total') || 0;
+
+      hasNextPage = currentPage * limit < total;
+
+      if (hasNextPage) {
+        nextPageParams = {
+          ...queryParams,
+          [config.pageParam || 'page']: String(currentPage + 1)
+        };
+      }
+      break;
+    }
+
+    case PaginationStrategy.CURSOR: {
+      const config = paginationConfig;
+      const nextCursor = getValueByPath(body, config.cursorPath || 'nextCursor');
+      const hasMore = getValueByPath(body, config.hasMorePath || 'hasMore');
+
+      hasNextPage = !!nextCursor || !!hasMore;
+
+      if (hasNextPage && nextCursor) {
+        nextPageParams = {
+          ...queryParams,
+          [config.cursorParam || 'cursor']: nextCursor
+        };
+      }
+      break;
+    }
+
+    case PaginationStrategy.LINK_HEADER: {
+      const linkHeader = response.headers['link'] || '';
+      // Handle both string and string[] types for the link header
+      const headerValue = Array.isArray(linkHeader) ? linkHeader[0] : linkHeader;
+      const links = parseLinkHeader(headerValue);
+
+      hasNextPage = !!links.next;
+
+      if (hasNextPage && links.next) {
+        // Extract query parameters from next link URL
+        const url = new URL(links.next);
+        nextPageParams = {};
+
+        url.searchParams.forEach((value, key) => {
+          nextPageParams[key] = value;
+        });
+      }
+      break;
+    }
+
+    case PaginationStrategy.CUSTOM: {
+      const config = paginationConfig;
+      hasNextPage = config.hasNextPage(response);
+
+      if (hasNextPage) {
+        nextPageParams = config.getNextPageParams(response, queryParams);
+      }
+      break;
+    }
+  }
+
+  // Create a function to fetch the next page
+  const getNextPage = async (): Promise<TPaginatedResponse<T>> => {
+    if (!hasNextPage) {
+      throw new Error('No more pages available');
+    }
+
+    return fetchNextPage(nextPageParams);
+  };
+
+  // Create a function to fetch all remaining pages
+  const getAllPages = async (): Promise<T[]> => {
+    const allItems = [...items];
+    let currentPage: TPaginatedResponse<T> = { items, hasNextPage, getNextPage, getAllPages, response };
+
+    while (currentPage.hasNextPage) {
+      try {
+        currentPage = await currentPage.getNextPage();
+        allItems.push(...currentPage.items);
+      } catch (error) {
+        break;
+      }
+    }
+
+    return allItems;
+  };
+
+  return {
+    items,
+    hasNextPage,
+    getNextPage,
+    getAllPages,
+    response
+  };
+}
+
+/**
+ * Parse Link header for pagination
+ * Link: <https://api.example.com/users?page=2>; rel="next", <https://api.example.com/users?page=5>; rel="last"
+ */
+export function parseLinkHeader(header: string): Record<string, string> {
+  const links: Record<string, string> = {};
+
+  if (!header) {
+    return links;
+  }
+
+  // Split parts by comma
+  const parts = header.split(',');
+
+  // Parse each part into a name:value pair
+  for (const part of parts) {
+    const section = part.split(';');
+    if (section.length < 2) {
+      continue;
+    }
+
+    const url = section[0].replace(/<(.*)>/, '$1').trim();
+    const name = section[1].replace(/rel="(.*)"/, '$1').trim();
+
+    links[name] = url;
+  }
+
+  return links;
+}
+
+/**
+ * Get a nested value from an object using dot notation path
+ * e.g., getValueByPath(obj, "data.pagination.nextCursor")
+ */
+export function getValueByPath(obj: any, path?: string): any {
+  if (!path || !obj) {
+    return undefined;
+  }
+
+  const keys = path.split('.');
+  let current = obj;
+
+  for (const key of keys) {
+    if (current === null || current === undefined || typeof current !== 'object') {
+      return undefined;
+    }
+    current = current[key];
+  }
+
+  return current;
+}
--- a/ts/client/index.ts
+++ b/ts/client/index.ts
@@ -0,0 +1,48 @@
+// Export the main client
+export { SmartRequest } from './smartrequest.js';
+
+// Export response type from core
+export { CoreResponse } from '../core/index.js';
+
+// Export types
+export type { HttpMethod, ResponseType, FormField, RetryConfig, TimeoutConfig } from './types/common.js';
+export { 
+  PaginationStrategy,
+  type TPaginationConfig as PaginationConfig,
+  type OffsetPaginationConfig,
+  type CursorPaginationConfig,
+  type LinkPaginationConfig,
+  type CustomPaginationConfig,
+  type TPaginatedResponse as PaginatedResponse
+} from './types/pagination.js';
+
+// Convenience factory functions
+import { SmartRequest } from './smartrequest.js';
+
+/**
+ * Create a client pre-configured for JSON requests
+ */
+export function createJsonClient<T = any>() {
+  return SmartRequest.create<T>();
+}
+
+/**
+ * Create a client pre-configured for form data requests
+ */
+export function createFormClient<T = any>() {
+  return SmartRequest.create<T>();
+}
+
+/**
+ * Create a client pre-configured for binary data
+ */
+export function createBinaryClient<T = any>() {
+  return SmartRequest.create<T>().accept('binary');
+}
+
+/**
+ * Create a client pre-configured for streaming
+ */
+export function createStreamClient() {
+  return SmartRequest.create().accept('stream');
+}
--- a/ts/client/plugins.ts
+++ b/ts/client/plugins.ts
@@ -0,0 +1,6 @@
+// plugins for client module
+import FormData from 'form-data';
+
+export {
+  FormData as formData
+};
--- a/ts/client/smartrequest.ts
+++ b/ts/client/smartrequest.ts
@@ -0,0 +1,332 @@
+import { CoreRequest, CoreResponse } from '../core/index.js';
+import type { ICoreResponse } from '../core_base/types.js';
+import * as plugins from './plugins.js';
+import type { ICoreRequestOptions } from '../core_base/types.js';
+
+import type { HttpMethod, ResponseType, FormField } from './types/common.js';
+import {
+  type TPaginationConfig,
+  PaginationStrategy,
+  type OffsetPaginationConfig,
+  type CursorPaginationConfig,
+  type CustomPaginationConfig,
+  type TPaginatedResponse
+} from './types/pagination.js';
+import { createPaginatedResponse } from './features/pagination.js';
+
+/**
+ * Modern fluent client for making HTTP requests
+ */
+export class SmartRequest<T = any> {
+  private _url: string;
+  private _options: ICoreRequestOptions = {};
+  private _retries: number = 0;
+  private _queryParams: Record<string, string> = {};
+  private _paginationConfig?: TPaginationConfig;
+
+  /**
+   * Create a new SmartRequest instance
+   */
+  static create<T = any>(): SmartRequest<T> {
+    return new SmartRequest<T>();
+  }
+
+  /**
+   * Set the URL for the request
+   */
+  url(url: string): this {
+    this._url = url;
+    return this;
+  }
+
+  /**
+   * Set the HTTP method
+   */
+  method(method: HttpMethod): this {
+    this._options.method = method;
+    return this;
+  }
+
+  /**
+   * Set JSON body for the request
+   */
+  json(data: any): this {
+    if (!this._options.headers) {
+      this._options.headers = {};
+    }
+    this._options.headers['Content-Type'] = 'application/json';
+    this._options.requestBody = data;
+    return this;
+  }
+
+  /**
+   * Set form data for the request
+   */
+  formData(data: FormField[]): this {
+    const form = new plugins.formData();
+
+    for (const item of data) {
+      if (Buffer.isBuffer(item.value)) {
+        form.append(item.name, item.value, {
+          filename: item.filename || 'file',
+          contentType: item.contentType || 'application/octet-stream'
+        });
+      } else {
+        form.append(item.name, item.value);
+      }
+    }
+
+    if (!this._options.headers) {
+      this._options.headers = {};
+    }
+
+    this._options.headers = {
+      ...this._options.headers,
+      ...form.getHeaders()
+    };
+
+    this._options.requestBody = form;
+    return this;
+  }
+
+  /**
+   * Set request timeout in milliseconds
+   */
+  timeout(ms: number): this {
+    this._options.timeout = ms;
+    this._options.hardDataCuttingTimeout = ms;
+    return this;
+  }
+
+  /**
+   * Set number of retry attempts
+   */
+  retry(count: number): this {
+    this._retries = count;
+    return this;
+  }
+
+  /**
+   * Set HTTP headers
+   */
+  headers(headers: Record<string, string>): this {
+    if (!this._options.headers) {
+      this._options.headers = {};
+    }
+    this._options.headers = {
+      ...this._options.headers,
+      ...headers
+    };
+    return this;
+  }
+
+  /**
+   * Set a single HTTP header
+   */
+  header(name: string, value: string): this {
+    if (!this._options.headers) {
+      this._options.headers = {};
+    }
+    this._options.headers[name] = value;
+    return this;
+  }
+
+  /**
+   * Set query parameters
+   */
+  query(params: Record<string, string>): this {
+    this._queryParams = {
+      ...this._queryParams,
+      ...params
+    };
+    return this;
+  }
+
+  /**
+   * Set the Accept header to indicate what content type is expected
+   */
+  accept(type: ResponseType): this {
+    // Map response types to Accept header values
+    const acceptHeaders: Record<ResponseType, string> = {
+      'json': 'application/json',
+      'text': 'text/plain',
+      'binary': 'application/octet-stream',
+      'stream': '*/*'
+    };
+    
+    return this.header('Accept', acceptHeaders[type]);
+  }
+
+  /**
+   * Configure pagination for requests
+   */
+  pagination(config: TPaginationConfig): this {
+    this._paginationConfig = config;
+    return this;
+  }
+
+  /**
+   * Configure offset-based pagination (page & limit)
+   */
+  withOffsetPagination(config: Omit<OffsetPaginationConfig, 'strategy'> = {}): this {
+    this._paginationConfig = {
+      strategy: PaginationStrategy.OFFSET,
+      pageParam: config.pageParam || 'page',
+      limitParam: config.limitParam || 'limit',
+      startPage: config.startPage || 1,
+      pageSize: config.pageSize || 20,
+      totalPath: config.totalPath || 'total'
+    };
+
+    // Add initial pagination parameters
+    this.query({
+      [this._paginationConfig.pageParam]: String(this._paginationConfig.startPage),
+      [this._paginationConfig.limitParam]: String(this._paginationConfig.pageSize)
+    });
+
+    return this;
+  }
+
+  /**
+   * Configure cursor-based pagination
+   */
+  withCursorPagination(config: Omit<CursorPaginationConfig, 'strategy'> = {}): this {
+    this._paginationConfig = {
+      strategy: PaginationStrategy.CURSOR,
+      cursorParam: config.cursorParam || 'cursor',
+      cursorPath: config.cursorPath || 'nextCursor',
+      hasMorePath: config.hasMorePath || 'hasMore'
+    };
+    return this;
+  }
+
+  /**
+   * Configure Link header-based pagination
+   */
+  withLinkPagination(): this {
+    this._paginationConfig = {
+      strategy: PaginationStrategy.LINK_HEADER
+    };
+    return this;
+  }
+
+  /**
+   * Configure custom pagination
+   */
+  withCustomPagination(config: Omit<CustomPaginationConfig, 'strategy'>): this {
+    this._paginationConfig = {
+      strategy: PaginationStrategy.CUSTOM,
+      hasNextPage: config.hasNextPage,
+      getNextPageParams: config.getNextPageParams
+    };
+    return this;
+  }
+
+  /**
+   * Make a GET request
+   */
+  async get<R = T>(): Promise<ICoreResponse<R>> {
+    return this.execute<R>('GET');
+  }
+
+  /**
+   * Make a POST request
+   */
+  async post<R = T>(): Promise<ICoreResponse<R>> {
+    return this.execute<R>('POST');
+  }
+
+  /**
+   * Make a PUT request
+   */
+  async put<R = T>(): Promise<ICoreResponse<R>> {
+    return this.execute<R>('PUT');
+  }
+
+  /**
+   * Make a DELETE request
+   */
+  async delete<R = T>(): Promise<ICoreResponse<R>> {
+    return this.execute<R>('DELETE');
+  }
+
+  /**
+   * Make a PATCH request
+   */
+  async patch<R = T>(): Promise<ICoreResponse<R>> {
+    return this.execute<R>('PATCH');
+  }
+
+  /**
+   * Get paginated response
+   */
+  async getPaginated<ItemType = T>(): Promise<TPaginatedResponse<ItemType>> {
+    if (!this._paginationConfig) {
+      throw new Error('Pagination not configured. Call one of the pagination methods first.');
+    }
+
+    // Default to GET if no method specified
+    if (!this._options.method) {
+      this._options.method = 'GET';
+    }
+
+    const response = await this.execute();
+
+    return await createPaginatedResponse<ItemType>(
+      response,
+      this._paginationConfig,
+      this._queryParams,
+      (nextPageParams) => {
+        // Create a new client with the same configuration but updated query params
+        const nextClient = new SmartRequest<ItemType>();
+        Object.assign(nextClient, this);
+        nextClient._queryParams = nextPageParams;
+
+        return nextClient.getPaginated<ItemType>();
+      }
+    );
+  }
+
+  /**
+   * Get all pages at once (use with caution for large datasets)
+   */
+  async getAllPages<ItemType = T>(): Promise<ItemType[]> {
+    const firstPage = await this.getPaginated<ItemType>();
+    return firstPage.getAllPages();
+  }
+
+  /**
+   * Execute the HTTP request
+   */
+  private async execute<R = T>(method?: HttpMethod): Promise<ICoreResponse<R>> {
+    if (method) {
+      this._options.method = method;
+    }
+
+    this._options.queryParams = this._queryParams;
+
+    // Handle retry logic
+    let lastError: Error;
+
+    for (let attempt = 0; attempt <= this._retries; attempt++) {
+      try {
+        const request = new CoreRequest(this._url, this._options as any);
+        const response = await request.fire();
+        return response as ICoreResponse<R>;
+      } catch (error) {
+        lastError = error as Error;
+
+        // If this is the last attempt, throw the error
+        if (attempt === this._retries) {
+          throw lastError;
+        }
+
+        // Otherwise, wait before retrying
+        await new Promise(resolve => setTimeout(resolve, 1000));
+      }
+    }
+
+    // This should never be reached due to the throw in the loop above
+    throw lastError;
+  }
+}
--- a/ts/client/types/common.ts
+++ b/ts/client/types/common.ts
@@ -0,0 +1,49 @@
+/**
+ * HTTP Methods supported by the client
+ */
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+
+/**
+ * Response types supported by the client
+ */
+export type ResponseType = 'json' | 'text' | 'binary' | 'stream';
+
+/**
+ * Form field data for multipart/form-data requests
+ */
+export interface FormField {
+  name: string;
+  value: string | Buffer;
+  filename?: string;
+  contentType?: string;
+}
+
+/**
+ * URL encoded form field
+ */
+export interface UrlEncodedField {
+  key: string;
+  value: string;
+}
+
+/**
+ * Retry configuration
+ */
+export interface RetryConfig {
+  attempts: number;         // Number of retry attempts
+  initialDelay?: number;    // Initial delay in ms
+  maxDelay?: number;        // Maximum delay in ms
+  factor?: number;          // Backoff factor
+  statusCodes?: number[];   // Status codes to retry on
+  shouldRetry?: (error: Error, attemptCount: number) => boolean;
+}
+
+/**
+ * Timeout configuration
+ */
+export interface TimeoutConfig {
+  request?: number;         // Overall request timeout in ms
+  connection?: number;      // Connection timeout in ms
+  socket?: number;          // Socket idle timeout in ms
+  response?: number;        // Response timeout in ms
+}
--- a/ts/client/types/pagination.ts
+++ b/ts/client/types/pagination.ts
@@ -0,0 +1,67 @@
+import { type CoreResponse } from '../../core/index.js';
+import type { ICoreResponse } from '../../core_base/types.js';
+
+/**
+ * Pagination strategy options
+ */
+export enum PaginationStrategy {
+  OFFSET = 'offset',        // Uses page & limit parameters
+  CURSOR = 'cursor',        // Uses a cursor/token for next page
+  LINK_HEADER = 'link',     // Uses Link headers
+  CUSTOM = 'custom'         // Uses a custom pagination handler
+}
+
+/**
+ * Configuration for offset-based pagination
+ */
+export interface OffsetPaginationConfig {
+  strategy: PaginationStrategy.OFFSET;
+  pageParam?: string;       // Parameter name for page number (default: "page")
+  limitParam?: string;      // Parameter name for page size (default: "limit")
+  startPage?: number;       // Starting page number (default: 1)
+  pageSize?: number;        // Number of items per page (default: 20)
+  totalPath?: string;       // JSON path to total item count (default: "total")
+}
+
+/**
+ * Configuration for cursor-based pagination
+ */
+export interface CursorPaginationConfig {
+  strategy: PaginationStrategy.CURSOR;
+  cursorParam?: string;     // Parameter name for cursor (default: "cursor")
+  cursorPath?: string;      // JSON path to next cursor (default: "nextCursor")
+  hasMorePath?: string;     // JSON path to check if more items exist (default: "hasMore")
+}
+
+/**
+ * Configuration for Link header-based pagination
+ */
+export interface LinkPaginationConfig {
+  strategy: PaginationStrategy.LINK_HEADER;
+  // No additional config needed, uses standard Link header format
+}
+
+/**
+ * Configuration for custom pagination
+ */
+export interface CustomPaginationConfig {
+  strategy: PaginationStrategy.CUSTOM;
+  hasNextPage: (response: ICoreResponse<any>) => boolean;
+  getNextPageParams: (response: ICoreResponse<any>, currentParams: Record<string, string>) => Record<string, string>;
+}
+
+/**
+ * Union type of all pagination configurations
+ */
+export type TPaginationConfig = OffsetPaginationConfig | CursorPaginationConfig | LinkPaginationConfig | CustomPaginationConfig;
+
+/**
+ * Interface for a paginated response
+ */
+export interface TPaginatedResponse<T> {
+  items: T[];                   // Current page items
+  hasNextPage: boolean;         // Whether there are more pages
+  getNextPage: () => Promise<TPaginatedResponse<T>>;  // Function to get the next page
+  getAllPages: () => Promise<T[]>;  // Function to get all remaining pages and combine
+  response: ICoreResponse<any>;  // Original response
+}
--- a/ts/core/index.ts
+++ b/ts/core/index.ts
@@ -0,0 +1,30 @@
+import * as plugins from './plugins.js';
+
+// Export all base types - these are the public API
+export * from '../core_base/types.js';
+
+const smartenvInstance = new plugins.smartenv.Smartenv();
+
+// Dynamically load the appropriate implementation
+let CoreRequest: any;
+let CoreResponse: any;
+
+if (smartenvInstance.isNode) {
+  // In Node.js, load the node implementation
+  const modulePath = plugins.smartpath.join(
+    plugins.smartpath.dirname(import.meta.url),
+    '../core_node/index.js'
+  )
+  console.log(modulePath);
+  const impl = await smartenvInstance.getSafeNodeModule(modulePath);
+  CoreRequest = impl.CoreRequest;
+  CoreResponse = impl.CoreResponse;
+} else {
+  // In browser, load the fetch implementation
+  const impl = await import('../core_fetch/index.js');
+  CoreRequest = impl.CoreRequest;
+  CoreResponse = impl.CoreResponse;
+}
+
+// Export the loaded implementations
+export { CoreRequest, CoreResponse };
--- a/ts/core/plugins.ts
+++ b/ts/core/plugins.ts
@@ -0,0 +1,4 @@
+import * as smartenv from '@push.rocks/smartenv';
+import * as smartpath from '@push.rocks/smartpath/iso';
+
+export { smartenv, smartpath };
--- a/ts/core_base/index.ts
+++ b/ts/core_base/index.ts
@@ -0,0 +1,4 @@
+// Core base exports - abstract classes and platform-agnostic types
+export * from './types.js';
+export * from './request.js';
+export * from './response.js';
--- a/ts/core_base/request.ts
+++ b/ts/core_base/request.ts
@@ -0,0 +1,45 @@
+import * as types from './types.js';
+
+/**
+ * Abstract Core Request class that defines the interface for all HTTP/HTTPS requests
+ */
+export abstract class CoreRequest<TOptions extends types.ICoreRequestOptions = types.ICoreRequestOptions, TResponse = any> {
+  /**
+   * Tests if a URL is a unix socket
+   */
+  static isUnixSocket(url: string): boolean {
+    const unixRegex = /^(http:\/\/|https:\/\/|)unix:/;
+    return unixRegex.test(url);
+  }
+
+  /**
+   * Parses socket path and route from unix socket URL
+   */
+  static parseUnixSocketUrl(url: string): { socketPath: string; path: string } {
+    const parseRegex = /(.*):(.*)/;
+    const result = parseRegex.exec(url);
+    return {
+      socketPath: result[1],
+      path: result[2],
+    };
+  }
+
+  protected url: string;
+  protected options: TOptions;
+
+  constructor(url: string, options?: TOptions) {
+    this.url = url;
+    this.options = options || ({} as TOptions);
+  }
+
+  /**
+   * Fire the request and return a response
+   */
+  abstract fire(): Promise<TResponse>;
+
+  /**
+   * Fire the request and return the raw response (platform-specific)
+   */
+  abstract fireCore(): Promise<any>;
+
+}
--- a/ts/core_base/response.ts
+++ b/ts/core_base/response.ts
@@ -0,0 +1,45 @@
+import * as types from './types.js';
+
+/**
+ * Abstract Core Response class that provides a fetch-like API
+ */
+export abstract class CoreResponse<T = any> implements types.ICoreResponse<T> {
+  protected consumed = false;
+
+  // Public properties
+  public abstract readonly ok: boolean;
+  public abstract readonly status: number;
+  public abstract readonly statusText: string;
+  public abstract readonly headers: types.Headers;
+  public abstract readonly url: string;
+
+  /**
+   * Ensures the body can only be consumed once
+   */
+  protected ensureNotConsumed(): void {
+    if (this.consumed) {
+      throw new Error('Body has already been consumed');
+    }
+    this.consumed = true;
+  }
+
+  /**
+   * Parse response as JSON
+   */
+  abstract json(): Promise<T>;
+
+  /**
+   * Get response as text
+   */
+  abstract text(): Promise<string>;
+
+  /**
+   * Get response as ArrayBuffer
+   */
+  abstract arrayBuffer(): Promise<ArrayBuffer>;
+  
+  /**
+   * Get response as a web-style ReadableStream
+   */
+  abstract stream(): ReadableStream<Uint8Array> | null;
+}
--- a/ts/core_base/types.ts
+++ b/ts/core_base/types.ts
@@ -0,0 +1,81 @@
+/**
+ * HTTP Methods supported
+ */
+export type THttpMethod = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS';
+
+/**
+ * Response types supported
+ */
+export type ResponseType = 'json' | 'text' | 'binary' | 'stream';
+
+/**
+ * Form field data for multipart/form-data requests
+ */
+export interface IFormField {
+  name: string;
+  value: string | Buffer;
+  filename?: string;
+  contentType?: string;
+}
+
+/**
+ * URL encoded form field
+ */
+export interface IUrlEncodedField {
+  key: string;
+  value: string;
+}
+
+/**
+ * Core request options - unified interface for all implementations
+ */
+export interface ICoreRequestOptions {
+  // Common options
+  method?: THttpMethod | string; // Allow string for compatibility
+  headers?: any; // Allow any for platform compatibility
+  keepAlive?: boolean;
+  requestBody?: any;
+  queryParams?: { [key: string]: string };
+  timeout?: number;
+  hardDataCuttingTimeout?: number;
+  
+  // Node.js specific options (ignored in fetch implementation)
+  agent?: any;
+  socketPath?: string;
+  hostname?: string;
+  port?: number;
+  path?: string;
+  
+  // Fetch API specific options (ignored in Node.js implementation)
+  credentials?: RequestCredentials;
+  mode?: RequestMode;
+  cache?: RequestCache;
+  redirect?: RequestRedirect;
+  referrer?: string;
+  referrerPolicy?: ReferrerPolicy;
+  integrity?: string;
+  signal?: AbortSignal;
+}
+
+/**
+ * Response headers - platform agnostic
+ */
+export type Headers = Record<string, string | string[]>;
+
+/**
+ * Core response interface - platform agnostic
+ */
+export interface ICoreResponse<T = any> {
+  // Properties
+  ok: boolean;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  url: string;
+  
+  // Methods
+  json(): Promise<T>;
+  text(): Promise<string>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  stream(): ReadableStream<Uint8Array> | null; // Always returns web-style stream
+}
--- a/ts/core_fetch/index.ts
+++ b/ts/core_fetch/index.ts
@@ -0,0 +1,3 @@
+// Core fetch exports - native fetch implementation
+export * from './response.js';
+export { CoreRequest } from './request.js';
--- a/ts/core_fetch/request.ts
+++ b/ts/core_fetch/request.ts
@@ -0,0 +1,131 @@
+import * as types from './types.js';
+import { CoreResponse } from './response.js';
+import { CoreRequest as AbstractCoreRequest } from '../core_base/request.js';
+
+/**
+ * Fetch-based implementation of Core Request class
+ */
+export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions, CoreResponse> {
+  constructor(url: string, options: types.ICoreRequestOptions = {}) {
+    super(url, options);
+    
+    // Check for unsupported Node.js-specific options
+    if (options.agent || options.socketPath) {
+      throw new Error('Node.js specific options (agent, socketPath) are not supported in browser/fetch implementation');
+    }
+  }
+
+  /**
+   * Build the full URL with query parameters
+   */
+  private buildUrl(): string {
+    if (!this.options.queryParams || Object.keys(this.options.queryParams).length === 0) {
+      return this.url;
+    }
+
+    const url = new URL(this.url);
+    Object.entries(this.options.queryParams).forEach(([key, value]) => {
+      url.searchParams.append(key, value);
+    });
+    return url.toString();
+  }
+
+  /**
+   * Convert our options to fetch RequestInit
+   */
+  private buildFetchOptions(): RequestInit {
+    const fetchOptions: RequestInit = {
+      method: this.options.method,
+      headers: this.options.headers,
+      credentials: this.options.credentials,
+      mode: this.options.mode,
+      cache: this.options.cache,
+      redirect: this.options.redirect,
+      referrer: this.options.referrer,
+      referrerPolicy: this.options.referrerPolicy,
+      integrity: this.options.integrity,
+      keepalive: this.options.keepAlive,
+      signal: this.options.signal,
+    };
+
+    // Handle request body
+    if (this.options.requestBody !== undefined) {
+      if (typeof this.options.requestBody === 'string' || 
+          this.options.requestBody instanceof ArrayBuffer ||
+          this.options.requestBody instanceof FormData ||
+          this.options.requestBody instanceof URLSearchParams ||
+          this.options.requestBody instanceof ReadableStream) {
+        fetchOptions.body = this.options.requestBody;
+      } else {
+        // Convert objects to JSON
+        fetchOptions.body = JSON.stringify(this.options.requestBody);
+        // Set content-type if not already set
+        if (!fetchOptions.headers) {
+          fetchOptions.headers = { 'Content-Type': 'application/json' };
+        } else if (fetchOptions.headers instanceof Headers) {
+          if (!fetchOptions.headers.has('Content-Type')) {
+            fetchOptions.headers.set('Content-Type', 'application/json');
+          }
+        } else if (typeof fetchOptions.headers === 'object' && !Array.isArray(fetchOptions.headers)) {
+          const headersObj = fetchOptions.headers as Record<string, string>;
+          if (!headersObj['Content-Type']) {
+            headersObj['Content-Type'] = 'application/json';
+          }
+        }
+      }
+    }
+
+    // Handle timeout
+    if (this.options.timeout || this.options.hardDataCuttingTimeout) {
+      const timeout = this.options.hardDataCuttingTimeout || this.options.timeout;
+      const controller = new AbortController();
+      setTimeout(() => controller.abort(), timeout);
+      fetchOptions.signal = controller.signal;
+    }
+
+    return fetchOptions;
+  }
+
+  /**
+   * Fire the request and return a CoreResponse
+   */
+  async fire(): Promise<CoreResponse> {
+    const response = await this.fireCore();
+    return new CoreResponse(response);
+  }
+
+  /**
+   * Fire the request and return the raw Response
+   */
+  async fireCore(): Promise<Response> {
+    const url = this.buildUrl();
+    const options = this.buildFetchOptions();
+    
+    try {
+      const response = await fetch(url, options);
+      return response;
+    } catch (error) {
+      if (error.name === 'AbortError') {
+        throw new Error('Request timed out');
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Static factory method to create and fire a request
+   */
+  static async create(
+    url: string,
+    options: types.ICoreRequestOptions = {}
+  ): Promise<CoreResponse> {
+    const request = new CoreRequest(url, options);
+    return request.fire();
+  }
+}
+
+/**
+ * Convenience exports for backward compatibility
+ */
+export const isUnixSocket = CoreRequest.isUnixSocket;
+export const parseUnixSocketUrl = CoreRequest.parseUnixSocketUrl;
--- a/ts/core_fetch/response.ts
+++ b/ts/core_fetch/response.ts
@@ -0,0 +1,85 @@
+import * as types from './types.js';
+import { CoreResponse as AbstractCoreResponse } from '../core_base/response.js';
+
+/**
+ * Fetch-based implementation of Core Response class
+ */
+export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements types.IFetchResponse<T> {
+  private response: Response;
+  private responseClone: Response;
+
+  // Public properties
+  public readonly ok: boolean;
+  public readonly status: number;
+  public readonly statusText: string;
+  public readonly headers: types.Headers;
+  public readonly url: string;
+
+  constructor(response: Response) {
+    super();
+    // Clone the response so we can read the body multiple times if needed
+    this.response = response;
+    this.responseClone = response.clone();
+    
+    this.ok = response.ok;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.url = response.url;
+    
+    // Convert Headers to plain object
+    this.headers = {};
+    response.headers.forEach((value, key) => {
+      this.headers[key] = value;
+    });
+  }
+
+  /**
+   * Parse response as JSON
+   */
+  async json(): Promise<T> {
+    this.ensureNotConsumed();
+    try {
+      return await this.response.json();
+    } catch (error) {
+      throw new Error(`Failed to parse JSON: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get response as text
+   */
+  async text(): Promise<string> {
+    this.ensureNotConsumed();
+    return await this.response.text();
+  }
+
+  /**
+   * Get response as ArrayBuffer
+   */
+  async arrayBuffer(): Promise<ArrayBuffer> {
+    this.ensureNotConsumed();
+    return await this.response.arrayBuffer();
+  }
+
+  /**
+   * Get response as a readable stream (Web Streams API)
+   */
+  stream(): ReadableStream<Uint8Array> | null {
+    this.ensureNotConsumed();
+    return this.response.body;
+  }
+
+  /**
+   * Node.js stream method - not available in browser
+   */
+  streamNode(): never {
+    throw new Error('streamNode() is not available in browser/fetch environment. Use stream() for web-style ReadableStream.');
+  }
+  
+  /**
+   * Get the raw Response object
+   */
+  raw(): Response {
+    return this.responseClone;
+  }
+}
--- a/ts/core_fetch/types.ts
+++ b/ts/core_fetch/types.ts
@@ -0,0 +1,15 @@
+import * as baseTypes from '../core_base/types.js';
+
+// Re-export base types
+export * from '../core_base/types.js';
+
+/**
+ * Fetch-specific response extensions
+ */
+export interface IFetchResponse<T = any> extends baseTypes.ICoreResponse<T> {
+  // Node.js stream method that throws in browser
+  streamNode(): never;
+  
+  // Access to raw Response object
+  raw(): Response;
+}
--- a/ts/core_node/index.ts
+++ b/ts/core_node/index.ts
@@ -0,0 +1,3 @@
+// Core exports
+export * from './response.js';
+export { CoreRequest } from './request.js';
--- a/ts/smartrequest.plugins.ts
+++ b/ts/smartrequest.plugins.ts
@@ -13,7 +13,8 @@ import * as smarturl from '@push.rocks/smarturl';
 export { smartpromise, smarturl };

 // third party scope
-import agentkeepalive from 'agentkeepalive';
+import { HttpAgent, HttpsAgent } from 'agentkeepalive';
+const agentkeepalive = { HttpAgent, HttpsAgent };
 import formData from 'form-data';

 export { agentkeepalive, formData };
--- a/ts/core_node/request.ts
+++ b/ts/core_node/request.ts
@@ -0,0 +1,163 @@
+import * as plugins from './plugins.js';
+import * as types from './types.js';
+import { CoreResponse } from './response.js';
+import { CoreRequest as AbstractCoreRequest } from '../core_base/request.js';
+
+// Keep-alive agents for connection pooling
+const httpAgent = new plugins.agentkeepalive.HttpAgent({
+  keepAlive: true,
+  maxFreeSockets: 10,
+  maxSockets: 100,
+  maxTotalSockets: 1000,
+});
+
+const httpAgentKeepAliveFalse = new plugins.agentkeepalive.HttpAgent({
+  keepAlive: false,
+});
+
+const httpsAgent = new plugins.agentkeepalive.HttpsAgent({
+  keepAlive: true,
+  maxFreeSockets: 10,
+  maxSockets: 100,
+  maxTotalSockets: 1000,
+});
+
+const httpsAgentKeepAliveFalse = new plugins.agentkeepalive.HttpsAgent({
+  keepAlive: false,
+});
+
+/**
+ * Node.js implementation of Core Request class that handles all HTTP/HTTPS requests
+ */
+export class CoreRequest extends AbstractCoreRequest<types.ICoreRequestOptions, CoreResponse> {
+  private requestDataFunc: ((req: plugins.http.ClientRequest) => void) | null;
+
+  constructor(
+    url: string,
+    options: types.ICoreRequestOptions = {},
+    requestDataFunc: ((req: plugins.http.ClientRequest) => void) | null = null
+  ) {
+    super(url, options);
+    this.requestDataFunc = requestDataFunc;
+    
+    // Check for unsupported fetch-specific options
+    if (options.credentials || options.mode || options.cache || options.redirect || 
+        options.referrer || options.referrerPolicy || options.integrity) {
+      throw new Error('Fetch API specific options (credentials, mode, cache, redirect, referrer, referrerPolicy, integrity) are not supported in Node.js implementation');
+    }
+  }
+
+  /**
+   * Fire the request and return a CoreResponse
+   */
+  async fire(): Promise<CoreResponse> {
+    const incomingMessage = await this.fireCore();
+    return new CoreResponse(incomingMessage, this.url);
+  }
+
+  /**
+   * Fire the request and return the raw IncomingMessage
+   */
+  async fireCore(): Promise<plugins.http.IncomingMessage> {
+    const done = plugins.smartpromise.defer<plugins.http.IncomingMessage>();
+
+    // Parse URL
+    const parsedUrl = plugins.smarturl.Smarturl.createFromUrl(this.url, {
+      searchParams: this.options.queryParams || {},
+    });
+    
+    this.options.hostname = parsedUrl.hostname;
+    if (parsedUrl.port) {
+      this.options.port = parseInt(parsedUrl.port, 10);
+    }
+    this.options.path = parsedUrl.path;
+
+    // Handle unix socket URLs
+    if (CoreRequest.isUnixSocket(this.url)) {
+      const { socketPath, path } = CoreRequest.parseUnixSocketUrl(this.options.path);
+      this.options.socketPath = socketPath;
+      this.options.path = path;
+    }
+
+    // Determine agent based on protocol and keep-alive setting
+    if (!this.options.agent) {
+      // Only use keep-alive agents if explicitly requested
+      if (this.options.keepAlive === true) {
+        this.options.agent = parsedUrl.protocol === 'https:' ? httpsAgent : httpAgent;
+      } else if (this.options.keepAlive === false) {
+        this.options.agent = parsedUrl.protocol === 'https:' ? httpsAgentKeepAliveFalse : httpAgentKeepAliveFalse;
+      }
+      // If keepAlive is undefined, don't set any agent (more fetch-like behavior)
+    }
+
+    // Determine request module
+    const requestModule = parsedUrl.protocol === 'https:' ? plugins.https : plugins.http;
+
+    if (!requestModule) {
+      throw new Error(`The request to ${this.url} is missing a viable protocol. Must be http or https`);
+    }
+
+    // Perform the request
+    const request = requestModule.request(this.options, async (response) => {
+      // Handle hard timeout
+      if (this.options.hardDataCuttingTimeout) {
+        setTimeout(() => {
+          response.destroy();
+          done.reject(new Error('Request timed out'));
+        }, this.options.hardDataCuttingTimeout);
+      }
+
+      // Always return the raw stream
+      done.resolve(response);
+    });
+
+    // Write request body
+    if (this.options.requestBody) {
+      if (this.options.requestBody instanceof plugins.formData) {
+        this.options.requestBody.pipe(request).on('finish', () => {
+          request.end();
+        });
+      } else {
+        // Write body as-is - caller is responsible for serialization
+        const bodyData = typeof this.options.requestBody === 'string' 
+          ? this.options.requestBody 
+          : this.options.requestBody instanceof Buffer 
+            ? this.options.requestBody
+            : JSON.stringify(this.options.requestBody); // Still stringify for backward compatibility
+        request.write(bodyData);
+        request.end();
+      }
+    } else if (this.requestDataFunc) {
+      this.requestDataFunc(request);
+    } else {
+      request.end();
+    }
+
+    // Handle request errors
+    request.on('error', (e) => {
+      console.error(e);
+      request.destroy();
+      done.reject(e);
+    });
+
+    // Get response and handle response errors
+    const response = await done.promise;
+    response.on('error', (err) => {
+      console.error(err);
+      response.destroy();
+    });
+
+    return response;
+  }
+
+  /**
+   * Static factory method to create and fire a request
+   */
+  static async create(
+    url: string,
+    options: types.ICoreRequestOptions = {}
+  ): Promise<CoreResponse> {
+    const request = new CoreRequest(url, options);
+    return request.fire();
+  }
+}
--- a/ts/core_node/response.ts
+++ b/ts/core_node/response.ts
@@ -0,0 +1,136 @@
+import * as plugins from './plugins.js';
+import * as types from './types.js';
+import { CoreResponse as AbstractCoreResponse } from '../core_base/response.js';
+
+/**
+ * Node.js implementation of Core Response class that provides a fetch-like API
+ */
+export class CoreResponse<T = any> extends AbstractCoreResponse<T> implements types.INodeResponse<T> {
+  private incomingMessage: plugins.http.IncomingMessage;
+  private bodyBufferPromise: Promise<Buffer> | null = null;
+
+  // Public properties
+  public readonly ok: boolean;
+  public readonly status: number;
+  public readonly statusText: string;
+  public readonly headers: plugins.http.IncomingHttpHeaders;
+  public readonly url: string;
+
+  constructor(incomingMessage: plugins.http.IncomingMessage, url: string) {
+    super();
+    this.incomingMessage = incomingMessage;
+    this.url = url;
+    this.status = incomingMessage.statusCode || 0;
+    this.statusText = incomingMessage.statusMessage || '';
+    this.ok = this.status >= 200 && this.status < 300;
+    this.headers = incomingMessage.headers;
+  }
+
+  /**
+   * Collects the body as a buffer
+   */
+  private async collectBody(): Promise<Buffer> {
+    this.ensureNotConsumed();
+    
+    if (this.bodyBufferPromise) {
+      return this.bodyBufferPromise;
+    }
+
+    this.bodyBufferPromise = new Promise<Buffer>((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      
+      this.incomingMessage.on('data', (chunk: Buffer) => {
+        chunks.push(chunk);
+      });
+      
+      this.incomingMessage.on('end', () => {
+        resolve(Buffer.concat(chunks));
+      });
+      
+      this.incomingMessage.on('error', reject);
+    });
+
+    return this.bodyBufferPromise;
+  }
+
+  /**
+   * Parse response as JSON
+   */
+  async json(): Promise<T> {
+    const buffer = await this.collectBody();
+    const text = buffer.toString('utf-8');
+    
+    try {
+      return JSON.parse(text);
+    } catch (error) {
+      throw new Error(`Failed to parse JSON: ${error.message}`);
+    }
+  }
+
+  /**
+   * Get response as text
+   */
+  async text(): Promise<string> {
+    const buffer = await this.collectBody();
+    return buffer.toString('utf-8');
+  }
+
+  /**
+   * Get response as ArrayBuffer
+   */
+  async arrayBuffer(): Promise<ArrayBuffer> {
+    const buffer = await this.collectBody();
+    return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+  }
+
+  /**
+   * Get response as a web-style ReadableStream
+   */
+  stream(): ReadableStream<Uint8Array> | null {
+    this.ensureNotConsumed();
+    
+    // Convert Node.js stream to web stream
+    // In Node.js 16.5+ we can use Readable.toWeb()
+    if (this.incomingMessage.readableEnded || this.incomingMessage.destroyed) {
+      return null;
+    }
+    
+    // Create a web ReadableStream from the Node.js stream
+    const nodeStream = this.incomingMessage;
+    return new ReadableStream<Uint8Array>({
+      start(controller) {
+        nodeStream.on('data', (chunk) => {
+          controller.enqueue(new Uint8Array(chunk));
+        });
+        
+        nodeStream.on('end', () => {
+          controller.close();
+        });
+        
+        nodeStream.on('error', (err) => {
+          controller.error(err);
+        });
+      },
+      
+      cancel() {
+        nodeStream.destroy();
+      }
+    });
+  }
+  
+  /**
+   * Get response as a Node.js readable stream
+   */
+  streamNode(): NodeJS.ReadableStream {
+    this.ensureNotConsumed();
+    return this.incomingMessage;
+  }
+
+  /**
+   * Get the raw IncomingMessage (for legacy compatibility)
+   */
+  raw(): plugins.http.IncomingMessage {
+    return this.incomingMessage;
+  }
+
+}
--- a/ts/core_node/types.ts
+++ b/ts/core_node/types.ts
@@ -0,0 +1,23 @@
+import * as plugins from './plugins.js';
+import * as baseTypes from '../core_base/types.js';
+
+// Re-export base types
+export * from '../core_base/types.js';
+
+/**
+ * Extended IncomingMessage with body property (legacy compatibility)
+ */
+export interface IExtendedIncomingMessage<T = any> extends plugins.http.IncomingMessage {
+  body: T;
+}
+
+/**
+ * Node.js specific response extensions
+ */
+export interface INodeResponse<T = any> extends baseTypes.ICoreResponse<T> {
+  // Node.js specific methods
+  streamNode(): NodeJS.ReadableStream; // Returns Node.js style stream
+  
+  // Legacy compatibility
+  raw(): plugins.http.IncomingMessage;
+}
--- a/ts/index.ts
+++ b/ts/index.ts
@@ -1,8 +1,10 @@
-export { request, safeGet } from './smartrequest.request.js';
-export type { IExtendedIncomingMessage } from './smartrequest.request.js';
-export type { ISmartRequestOptions } from './smartrequest.interfaces.js';
+// Client API exports
+export * from './client/index.js';

-export * from './smartrequest.jsonrest.js';
-export * from './smartrequest.binaryrest.js';
-export * from './smartrequest.formdata.js';
-export * from './smartrequest.stream.js';
+// Core exports for advanced usage
+export { CoreResponse } from './core/index.js';
+export type { ICoreRequestOptions, ICoreResponse } from './core_base/types.js';
+
+// Default export for easier importing
+import { SmartRequest } from './client/smartrequest.js';
+export default SmartRequest;
--- a/ts/smartrequest.binaryrest.ts
+++ b/ts/smartrequest.binaryrest.ts
@@ -1,33 +0,0 @@
-// this file implements methods to get and post binary data.
-import * as interfaces from './smartrequest.interfaces.js';
-import { request, type IExtendedIncomingMessage } from './smartrequest.request.js';
-
-import * as plugins from './smartrequest.plugins.js';
-
-export const getBinary = async (
-  domainArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {}
-) => {
-  optionsArg = {
-    ...optionsArg,
-    autoJsonParse: false,
-  };
-  const done = plugins.smartpromise.defer();
-  const response = await request(domainArg, optionsArg, true);
-  const data: Array<Buffer> = [];
-
-  response
-    .on('data', function (chunk: Buffer) {
-      data.push(chunk);
-    })
-    .on('end', function () {
-      //at this point data is an array of Buffers
-      //so Buffer.concat() can make us a new Buffer
-      //of all of them together
-      const buffer = Buffer.concat(data);
-      response.body = buffer;
-      done.resolve();
-    });
-  await done.promise;
-  return response as IExtendedIncomingMessage<Buffer>;
-};
--- a/ts/smartrequest.formdata.ts
+++ b/ts/smartrequest.formdata.ts
@@ -1,99 +0,0 @@
-import * as plugins from './smartrequest.plugins.js';
-import * as interfaces from './smartrequest.interfaces.js';
-import { request } from './smartrequest.request.js';
-
-/**
- * the interfae for FormFieldData
- */
-export interface IFormField {
-  name: string;
-  type: 'string' | 'filePath' | 'Buffer';
-  payload: string | Buffer;
-  fileName?: string;
-  contentType?: string;
-}
-
-const appendFormField = async (formDataArg: plugins.formData, formDataField: IFormField) => {
-  switch (formDataField.type) {
-    case 'string':
-      formDataArg.append(formDataField.name, formDataField.payload);
-      break;
-    case 'filePath':
-      if (typeof formDataField.payload !== 'string') {
-        throw new Error(
-          `Payload for key ${
-            formDataField.name
-          } must be of type string. Got ${typeof formDataField.payload} instead.`
-        );
-      }
-      const fileData = plugins.fs.readFileSync(
-        plugins.path.join(process.cwd(), formDataField.payload)
-      );
-      formDataArg.append('file', fileData, {
-        filename: formDataField.fileName ? formDataField.fileName : 'upload.pdf',
-        contentType: 'application/pdf',
-      });
-      break;
-    case 'Buffer':
-      formDataArg.append(formDataField.name, formDataField.payload, {
-        filename: formDataField.fileName ? formDataField.fileName : 'upload.pdf',
-        contentType: formDataField.contentType ? formDataField.contentType : 'application/pdf',
-      });
-      break;
-  }
-};
-
-export const postFormData = async (
-  urlArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {},
-  payloadArg: IFormField[]
-) => {
-  const form = new plugins.formData();
-  for (const formField of payloadArg) {
-    await appendFormField(form, formField);
-  }
-  const requestOptions = {
-    ...optionsArg,
-    method: 'POST',
-    headers: {
-      ...optionsArg.headers,
-      ...form.getHeaders(),
-    },
-    requestBody: form,
-  };
-
-  // lets fire the actual request for sending the formdata
-  const response = await request(urlArg, requestOptions);
-  return response;
-};
-
-export const postFormDataUrlEncoded = async (
-  urlArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {},
-  payloadArg: { key: string; content: string }[]
-) => {
-  let resultString = '';
-
-  for (const keyContentPair of payloadArg) {
-    if (resultString) {
-      resultString += '&';
-    }
-    resultString += `${encodeURIComponent(keyContentPair.key)}=${encodeURIComponent(
-      keyContentPair.content
-    )}`;
-  }
-
-  const requestOptions: interfaces.ISmartRequestOptions = {
-    ...optionsArg,
-    method: 'POST',
-    headers: {
-      ...optionsArg.headers,
-      'content-type': 'application/x-www-form-urlencoded',
-    },
-    requestBody: resultString,
-  };
-
-  // lets fire the actual request for sending the formdata
-  const response = await request(urlArg, requestOptions);
-  return response;
-};
--- a/ts/smartrequest.interfaces.ts
+++ b/ts/smartrequest.interfaces.ts
@@ -1,10 +0,0 @@
-import * as plugins from './smartrequest.plugins.js';
-import * as https from 'https';
-
-export interface ISmartRequestOptions extends https.RequestOptions {
-  keepAlive?: boolean;
-  requestBody?: any;
-  autoJsonParse?: boolean;
-  queryParams?: { [key: string]: string };
-  hardDataCuttingTimeout?: number;
-}
--- a/ts/smartrequest.jsonrest.ts
+++ b/ts/smartrequest.jsonrest.ts
@@ -1,63 +0,0 @@
-// This file implements methods to get and post JSON in a simple manner.
-
-import * as interfaces from './smartrequest.interfaces.js';
-import { request } from './smartrequest.request.js';
-
-/**
- * gets Json and puts the right headers + handles response aggregation
- * @param domainArg
- * @param optionsArg
- */
-export const getJson = async (
-  domainArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {}
-) => {
-  optionsArg.method = 'GET';
-  optionsArg.headers = {
-    ...optionsArg.headers,
-  };
-  let response = await request(domainArg, optionsArg);
-  return response;
-};
-
-export const postJson = async (
-  domainArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {}
-) => {
-  optionsArg.method = 'POST';
-  if (
-    typeof optionsArg.requestBody === 'object' &&
-    (!optionsArg.headers || !optionsArg.headers['Content-Type'])
-  ) {
-    // make sure headers exist
-    if (!optionsArg.headers) {
-      optionsArg.headers = {};
-    }
-
-    // assign the right Content-Type, leaving all other headers in place
-    optionsArg.headers = {
-      ...optionsArg.headers,
-      'Content-Type': 'application/json',
-    };
-  }
-  let response = await request(domainArg, optionsArg);
-  return response;
-};
-
-export const putJson = async (
-  domainArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {}
-) => {
-  optionsArg.method = 'PUT';
-  let response = await request(domainArg, optionsArg);
-  return response;
-};
-
-export const delJson = async (
-  domainArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {}
-) => {
-  optionsArg.method = 'DELETE';
-  let response = await request(domainArg, optionsArg);
-  return response;
-};
--- a/ts/smartrequest.request.ts
+++ b/ts/smartrequest.request.ts
@@ -1,231 +0,0 @@
-import * as plugins from './smartrequest.plugins.js';
-import * as interfaces from './smartrequest.interfaces.js';
-
-export interface IExtendedIncomingMessage<T = any> extends plugins.http.IncomingMessage {
-  body: T;
-}
-
-const buildUtf8Response = (
-  incomingMessageArg: plugins.http.IncomingMessage,
-  autoJsonParse = true
-): Promise<IExtendedIncomingMessage> => {
-  const done = plugins.smartpromise.defer<IExtendedIncomingMessage>();
-  // Continuously update stream with data
-  let body = '';
-  incomingMessageArg.on('data', (chunkArg) => {
-    body += chunkArg;
-  });
-
-  incomingMessageArg.on('end', () => {
-    if (autoJsonParse) {
-      try {
-        (incomingMessageArg as IExtendedIncomingMessage).body = JSON.parse(body);
-      } catch (err) {
-        (incomingMessageArg as IExtendedIncomingMessage).body = body;
-      }
-    } else {
-      (incomingMessageArg as IExtendedIncomingMessage).body = body;
-    }
-    done.resolve(incomingMessageArg as IExtendedIncomingMessage);
-  });
-  return done.promise;
-};
-
-/**
- * determine wether a url is a unix sock
- * @param urlArg
- */
-const testForUnixSock = (urlArg: string): boolean => {
-  const unixRegex = /^(http:\/\/|https:\/\/|)unix:/;
-  return unixRegex.test(urlArg);
-};
-
-/**
- * determine socketPath and path for unixsock
- */
-const parseSocketPathAndRoute = (stringToParseArg: string) => {
-  const parseRegex = /(.*):(.*)/;
-  const result = parseRegex.exec(stringToParseArg);
-  return {
-    socketPath: result[1],
-    path: result[2],
-  };
-};
-
-/**
- * a custom http agent to make sure we can set custom keepAlive options for speedy subsequent calls
- */
-const httpAgent = new plugins.agentkeepalive({
-  keepAlive: true,
-  maxFreeSockets: 10,
-  maxSockets: 100,
-  maxTotalSockets: 1000,
-  timeout: 60000,
-});
-
-/**
- * a custom http agent to make sure we can set custom keepAlive options for speedy subsequent calls
- */
-const httpAgentKeepAliveFalse = new plugins.agentkeepalive({
-  keepAlive: false,
-  timeout: 60000,
-});
-
-/**
- * a custom https agent to make sure we can set custom keepAlive options for speedy subsequent calls
- */
-const httpsAgent = new plugins.agentkeepalive.HttpsAgent({
-  keepAlive: true,
-  maxFreeSockets: 10,
-  maxSockets: 100,
-  maxTotalSockets: 1000,
-  timeout: 60000,
-});
-
-/**
- * a custom https agent to make sure we can set custom keepAlive options for speedy subsequent calls
- */
-const httpsAgentKeepAliveFalse = new plugins.agentkeepalive.HttpsAgent({
-  keepAlive: false,
-  timeout: 60000,
-});
-
-export let request = async (
-  urlArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {},
-  responseStreamArg: boolean = false,
-  requestDataFunc: (req: plugins.http.ClientRequest) => void = null
-): Promise<IExtendedIncomingMessage> => {
-  const done = plugins.smartpromise.defer<IExtendedIncomingMessage>();
-
-  // merge options
-  const defaultOptions: interfaces.ISmartRequestOptions = {
-    // agent: agent,
-    autoJsonParse: true,
-    keepAlive: true,
-  };
-
-  optionsArg = {
-    ...defaultOptions,
-    ...optionsArg,
-  };
-
-  // parse url
-  const parsedUrl = plugins.smarturl.Smarturl.createFromUrl(urlArg, {
-    searchParams: optionsArg.queryParams || {},
-  });
-  optionsArg.hostname = parsedUrl.hostname;
-  if (parsedUrl.port) {
-    optionsArg.port = parseInt(parsedUrl.port, 10);
-  }
-  optionsArg.path = parsedUrl.path;
-  optionsArg.queryParams = parsedUrl.searchParams;
-
-  // determine if unixsock
-  if (testForUnixSock(urlArg)) {
-    const detailedUnixPath = parseSocketPathAndRoute(optionsArg.path);
-    optionsArg.socketPath = detailedUnixPath.socketPath;
-    optionsArg.path = detailedUnixPath.path;
-  }
-
-  // TODO: support tcp sockets
-
-  // lets determine agent
-  switch (true) {
-    case !!optionsArg.agent:
-      break;
-    case parsedUrl.protocol === 'https:' && optionsArg.keepAlive:
-      optionsArg.agent = httpsAgent;
-      break;
-    case parsedUrl.protocol === 'https:' && !optionsArg.keepAlive:
-      optionsArg.agent = httpsAgentKeepAliveFalse;
-      break;
-    case parsedUrl.protocol === 'http:' && optionsArg.keepAlive:
-      optionsArg.agent = httpAgent;
-      break;
-    case parsedUrl.protocol === 'http:' && !optionsArg.keepAlive:
-      optionsArg.agent = httpAgentKeepAliveFalse;
-      break;
-  }
-
-  // lets determine the request module to use
-  const requestModule = (() => {
-    switch (true) {
-      case parsedUrl.protocol === 'https:':
-        return plugins.https;
-      case parsedUrl.protocol === 'http:':
-        return plugins.http;
-    }
-  })() as typeof plugins.https;
-
-  if (!requestModule) {
-    console.error(`The request to ${urlArg} is missing a viable protocol. Must be http or https`);
-    return;
-  }
-
-  // lets perform the actual request
-  const requestToFire = requestModule.request(optionsArg, async (resArg) => {
-    if (optionsArg.hardDataCuttingTimeout) {
-      setTimeout(() => {
-        resArg.destroy();
-        done.reject(new Error('Request timed out'));
-      }, optionsArg.hardDataCuttingTimeout)
-    }
-
-    if (responseStreamArg) {
-      done.resolve(resArg as IExtendedIncomingMessage);
-    } else {
-      const builtResponse = await buildUtf8Response(resArg, optionsArg.autoJsonParse);
-      done.resolve(builtResponse);
-    }
-  });
-
-  // lets write the requestBody
-  if (optionsArg.requestBody) {
-    if (optionsArg.requestBody instanceof plugins.formData) {
-      optionsArg.requestBody.pipe(requestToFire).on('finish', (event: any) => {
-        requestToFire.end();
-      });
-    } else {
-      if (typeof optionsArg.requestBody !== 'string') {
-        optionsArg.requestBody = JSON.stringify(optionsArg.requestBody);
-      }
-      requestToFire.write(optionsArg.requestBody);
-      requestToFire.end();
-    }
-  } else if (requestDataFunc) {
-    requestDataFunc(requestToFire);
-  } else {
-    requestToFire.end();
-  }
-
-  // lets handle an error
-  requestToFire.on('error', (e) => {
-    console.error(e);
-    requestToFire.destroy();
-  });
-
-  const response = await done.promise;
-  response.on('error', (err) => {
-    console.log(err);
-    response.destroy();
-  });
-  return response;
-};
-
-export const safeGet = async (urlArg: string) => {
-  const agentToUse = urlArg.startsWith('http://') ? new plugins.http.Agent() : new plugins.https.Agent();
-  try {
-    const response = await request(urlArg, {
-      method: 'GET',
-      agent: agentToUse,
-      timeout: 5000,
-      hardDataCuttingTimeout: 5000,
-      autoJsonParse: false,
-    });
-    return response;
-  } catch (err) {
-    console.log(err);
-    return null;
-  }
-};
--- a/ts/smartrequest.stream.ts
+++ b/ts/smartrequest.stream.ts
@@ -1,17 +0,0 @@
-import * as plugins from './smartrequest.plugins.js';
-import * as interfaces from './smartrequest.interfaces.js';
-import { request } from './smartrequest.request.js';
-
-export const getStream = async (
-  urlArg: string,
-  optionsArg: interfaces.ISmartRequestOptions = {}
-): Promise<plugins.http.IncomingMessage> => {
-  try {
-    // Call the existing request function with responseStreamArg set to true.
-    const responseStream = await request(urlArg, optionsArg, true);
-    return responseStream;
-  } catch (err) {
-    console.error('An error occurred while getting the stream:', err);
-    throw err; // Rethrow the error to be handled by the caller.
-  }
-};
Author	SHA1	Message	Date
Juergen Kunz	cf24bf94b9	4.0.1 Some checks failed Default (tags) / security (push) Failing after 25s Details Default (tags) / test (push) Failing after 15s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-07-29 00:19:30 +00:00
Juergen Kunz	3e24f1c5a8	fix:(exports)	2025-07-29 00:19:19 +00:00
Juergen Kunz	2dc82bd730	BREAKING CHANGE(core): major architectural refactoring with cross-platform support and SmartRequest rename Some checks failed Default (tags) / security (push) Failing after 24s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-07-28 23:20:52 +00:00
Juergen Kunz	8e75047d1f	update	2025-07-28 22:50:12 +00:00
Juergen Kunz	eb2ccd8d9f	update	2025-07-28 22:37:36 +00:00
Juergen Kunz	bc99aa3569	update	2025-07-28 17:23:48 +00:00
Juergen Kunz	94bf23ad55	update	2025-07-28 17:15:35 +00:00
Juergen Kunz	ea54a8aeda	update	2025-07-28 17:07:24 +00:00
Juergen Kunz	18d8ab0278	update	2025-07-28 17:01:34 +00:00
Juergen Kunz	b8d707b363	update	2025-07-28 16:51:30 +00:00
Juergen Kunz	7dcc5f3fe2	update	2025-07-28 15:12:11 +00:00
Juergen Kunz	8f5c88b47e	update	2025-07-28 15:12:04 +00:00
Juergen Kunz	28a56b87bc	update	2025-07-28 15:00:42 +00:00
Juergen Kunz	d627bc870e	update	2025-07-28 14:45:47 +00:00
Juergen Kunz	2cded974a8	update	2025-07-28 14:38:09 +00:00
Juergen Kunz	31c25c8333	update	2025-07-28 14:30:27 +00:00
Juergen Kunz	01bbfa4a06	fix tests	2025-07-28 14:21:42 +00:00
Juergen Kunz	0ebd47d1b2	update readme.md	2025-07-28 07:45:37 +00:00
Juergen Kunz	bbb57004d9	BREAKING CHANGE(core): major architectural refactoring with fetch-like API Some checks failed Default (tags) / security (push) Failing after 24s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-07-27 21:23:20 +00:00
Philipp Kunz	f7d2c6de4f	2.1.0 Some checks failed Default (tags) / security (push) Failing after 23s Details Default (tags) / test (push) Failing after 9s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-04-03 06:52:58 +00:00
Philipp Kunz	b8f545cdd5	feat(docs): Enhance documentation and tests with modern API usage examples and migration guide	2025-04-03 06:52:58 +00:00
Philipp Kunz	96820090d4	add modern version of request construction	2025-04-03 06:36:48 +00:00