@deepraxis/sdk 0.0.0-stage → 0.1.0-dev.ea77ce8

package/dist/core/errors.js

@@ -0,0 +1,60 @@
+/** Pure normalization shared by HTTP clients and the automation call ledger.
+ * Numeric transport codes (E2B's `code: 400`) are not domain error codes.
+ */
+export function problemFrom(status, headers, body, statusText) {
+    const value = body && typeof body === 'object' ? body : {};
+    const nested = value.error && typeof value.error === 'object' ? value.error : {};
+    const string = (v) => typeof v === 'string' && v.trim() ? v : undefined;
+    const fallback = statusText || { 400: 'Bad Request', 401: 'Unauthorized', 403: 'Forbidden', 404: 'Not Found', 405: 'Method Not Allowed', 408: 'Request Timeout', 409: 'Conflict', 413: 'Payload Too Large', 415: 'Unsupported Media Type', 422: 'Unprocessable Entity', 429: 'Too Many Requests', 500: 'Internal Server Error', 502: 'Bad Gateway', 503: 'Service Unavailable', 504: 'Gateway Timeout' }[status] || `HTTP ${status}`;
+    const detail = string(value.detail) ?? string(nested.message) ?? string(value.message) ?? string(body);
+    const title = string(value.title) ?? fallback;
+    const param = nested.param ?? value.param;
+    return {
+        status, message: detail ?? title, title, detail,
+        code: string(value.code) ?? string(nested.code) ?? string(nested.type) ?? string(value.error_code),
+        type: string(nested.type) ?? string(value.type),
+        param: typeof param === 'string' ? param : param === null || nested.param === null ? null : undefined,
+        errors: Array.isArray(value.errors) ? value.errors : [],
+        requestId: headers.get('x-request-id') ?? string(value.requestId) ?? string(value.request_id),
+        raw: body,
+    };
+}
+export class PraxisError extends Error {
+    status;
+    code;
+    type;
+    title;
+    detail;
+    errors;
+    requestId;
+    param;
+    raw;
+    constructor(problem = {}, options) {
+        super(problem.message ?? problem.detail ?? problem.title ?? `Praxis request failed${problem.status ? ` (${problem.status})` : ''}`, options);
+        this.name = 'PraxisError';
+        this.status = problem.status;
+        this.code = problem.code;
+        this.type = problem.type;
+        this.title = problem.title;
+        this.detail = problem.detail;
+        this.errors = problem.errors ?? [];
+        this.requestId = problem.requestId;
+        this.param = problem.param;
+        this.raw = problem.raw;
+    }
+    static fromResponse(response, body) {
+        return new PraxisError(problemFrom(response.status, response.headers, body, response.statusText));
+    }
+}
+export class PraxisConnectionError extends PraxisError {
+    constructor(cause) {
+        super({ code: 'CONNECTION_ERROR', title: 'Unable to connect to Praxis' }, { cause });
+        this.name = 'PraxisConnectionError';
+    }
+}
+export class PraxisTimeoutError extends PraxisError {
+    constructor(timeoutMs) {
+        super({ code: 'TIMEOUT', title: `Praxis request exceeded ${timeoutMs} ms` });
+        this.name = 'PraxisTimeoutError';
+    }
+}

package/dist/core/multipart.d.ts

@@ -0,0 +1,2 @@
+/** Expand plain objects into bracketed fields; arrays repeat the same field name. */
+export declare function multipartBodySerializer(body: unknown): FormData;

package/dist/core/multipart.js

@@ -0,0 +1,25 @@
+/** Expand plain objects into bracketed fields; arrays repeat the same field name. */
+export function multipartBodySerializer(body) {
+    const data = new FormData();
+    function append(key, value) {
+        if (value === undefined || value === null)
+            return;
+        if (value instanceof Blob) {
+            data.append(key, value);
+        }
+        else if (Array.isArray(value)) {
+            for (const item of value)
+                append(key, item);
+        }
+        else if (typeof value === 'object' && (Object.getPrototypeOf(value) === Object.prototype || Object.getPrototypeOf(value) === null)) {
+            for (const [subkey, item] of Object.entries(value))
+                append(`${key}[${subkey}]`, item);
+        }
+        else {
+            data.append(key, String(value));
+        }
+    }
+    for (const [key, value] of Object.entries((body ?? {})))
+        append(key, value);
+    return data;
+}

package/dist/core/pagination.d.ts

@@ -0,0 +1,12 @@
+export interface PageData<T> {
+    data: T[];
+    next_cursor?: string | null;
+}
+export declare class Page<T> implements AsyncIterable<T> {
+    private readonly load;
+    readonly data: T[];
+    readonly next_cursor: string | null;
+    constructor(value: PageData<T>, load: (cursor: string) => Promise<Page<T>>);
+    nextPage(): Promise<Page<T> | null>;
+    [Symbol.asyncIterator](): AsyncGenerator<T>;
+}

package/dist/core/pagination.js

@@ -0,0 +1,26 @@
+export class Page {
+    load;
+    data;
+    next_cursor;
+    constructor(value, load) {
+        this.load = load;
+        this.data = value.data;
+        this.next_cursor = value.next_cursor ?? null;
+    }
+    nextPage() {
+        return this.next_cursor ? this.load(this.next_cursor) : Promise.resolve(null);
+    }
+    async *[Symbol.asyncIterator]() {
+        let page = this;
+        const seen = new Set();
+        while (page) {
+            yield* page.data;
+            if (page.next_cursor) {
+                if (seen.has(page.next_cursor))
+                    throw new Error('Praxis pagination repeated a cursor');
+                seen.add(page.next_cursor);
+            }
+            page = await page.nextPage();
+        }
+    }
+}

package/dist/core/retry.d.ts

@@ -0,0 +1,13 @@
+export declare function canRetry(request: Request): boolean;
+export declare function retryAfterMs(value: string | null, now?: number): number | undefined;
+export declare function retryDelay(attempt: number, retryAfter: string | null, random?: () => number): number;
+export declare function abortable<T>(promise: Promise<T>, signal: AbortSignal): Promise<T>;
+export declare function sleep(ms: number, signal: AbortSignal): Promise<void>;
+export interface RetryOptions {
+    maxRetries: number;
+    signal: AbortSignal;
+    /** Deterministic test seam; production uses real cancellable timers. */
+    wait?: (ms: number, signal: AbortSignal) => Promise<void>;
+    random?: () => number;
+}
+export declare function fetchWithRetry(request: Request, fetcher: typeof globalThis.fetch, options: RetryOptions): Promise<Response>;

package/dist/core/retry.js

@@ -0,0 +1,56 @@
+import { PraxisConnectionError } from "./errors.js";
+export function canRetry(request) {
+    return request.method !== 'POST' || Boolean(request.headers.get('Idempotency-Key')?.trim());
+}
+export function retryAfterMs(value, now = Date.now()) {
+    if (!value)
+        return undefined;
+    if (/^\d+(?:\.\d+)?$/.test(value.trim()))
+        return Number(value) * 1000;
+    const date = Date.parse(value);
+    return Number.isFinite(date) ? Math.max(0, date - now) : undefined;
+}
+export function retryDelay(attempt, retryAfter, random = Math.random) {
+    return retryAfterMs(retryAfter) ?? Math.min(30_000, 500 * 2 ** attempt) * (0.5 + random() * 0.5);
+}
+export function abortable(promise, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const abort = () => reject(signal.reason);
+        signal.addEventListener('abort', abort, { once: true });
+        promise.then(resolve, reject).finally(() => signal.removeEventListener('abort', abort));
+    });
+}
+export function sleep(ms, signal) {
+    signal.throwIfAborted();
+    return new Promise((resolve, reject) => {
+        const abort = () => { clearTimeout(timer); reject(signal.reason); };
+        const timer = setTimeout(() => { signal.removeEventListener('abort', abort); resolve(); }, ms);
+        signal.addEventListener('abort', abort, { once: true });
+    });
+}
+export async function fetchWithRetry(request, fetcher, options) {
+    const eligible = canRetry(request);
+    const wait = options.wait ?? sleep;
+    for (let attempt = 0;; attempt++) {
+        options.signal.throwIfAborted();
+        let response;
+        try {
+            // Preserve a replayable request; never reuse a consumed body on the next attempt.
+            response = await abortable(fetcher(request.clone()), options.signal);
+        }
+        catch (cause) {
+            options.signal.throwIfAborted();
+            if (!eligible || attempt >= options.maxRetries)
+                throw new PraxisConnectionError(cause);
+            await wait(retryDelay(attempt, null, options.random), options.signal);
+            continue;
+        }
+        const retriable = response.status === 408 || response.status === 429 || (response.status >= 500 && response.status <= 599);
+        if (!eligible || !retriable || attempt >= options.maxRetries)
+            return response;
+        const delay = retryDelay(attempt, response.headers.get('Retry-After'), options.random);
+        await response.body?.cancel();
+        await wait(delay, options.signal);
+    }
+}

package/dist/core/sse.d.ts

@@ -0,0 +1,13 @@
+export interface SSEEvent<T = unknown> {
+    id?: string;
+    event?: string;
+    data: T;
+}
+export interface SSEOptions {
+    lastEventId?: string;
+    signal?: AbortSignal;
+    onId?: (id: string) => void;
+    onRetry?: (milliseconds: number) => void;
+}
+/** Incremental SSE framing: UTF-8, LF/CR/CRLF, comments and multiline data. */
+export declare function parseSSE(body: ReadableStream<Uint8Array>, options?: SSEOptions): AsyncGenerator<SSEEvent>;

package/dist/core/sse.js

@@ -0,0 +1,67 @@
+import { abortable } from "./retry.js";
+/** Incremental SSE framing: UTF-8, LF/CR/CRLF, comments and multiline data. */
+export async function* parseSSE(body, options = {}) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let pending = '', data = [], event = '', id = options.lastEventId;
+    function line(value) {
+        if (value === '') {
+            const kind = event;
+            event = '';
+            if (!data.length && kind !== 'end')
+                return;
+            const text = data.join('\n');
+            data = [];
+            let parsed = text;
+            try {
+                parsed = JSON.parse(text);
+            }
+            catch { /* SSE data can be plain text. */ }
+            return { ...(id === undefined ? {} : { id }), ...(kind ? { event: kind } : {}), data: parsed };
+        }
+        if (value.startsWith(':'))
+            return;
+        const colon = value.indexOf(':');
+        const field = colon < 0 ? value : value.slice(0, colon);
+        let content = colon < 0 ? '' : value.slice(colon + 1);
+        if (content.startsWith(' '))
+            content = content.slice(1);
+        if (field === 'data')
+            data.push(content);
+        else if (field === 'event')
+            event = content;
+        else if (field === 'id' && !content.includes('\0')) {
+            id = content;
+            options.onId?.(id);
+        }
+        else if (field === 'retry' && /^\d+$/.test(content) && Number.isSafeInteger(Number(content)))
+            options.onRetry?.(Number(content));
+    }
+    try {
+        for (;;) {
+            const result = options.signal ? await abortable(reader.read(), options.signal) : await reader.read();
+            pending += result.done ? decoder.decode() : decoder.decode(result.value, { stream: true });
+            for (;;) {
+                const at = pending.search(/[\r\n]/);
+                if (at < 0 || (!result.done && pending[at] === '\r' && at === pending.length - 1))
+                    break;
+                const value = pending.slice(0, at);
+                const width = pending[at] === '\r' && pending[at + 1] === '\n' ? 2 : 1;
+                pending = pending.slice(at + width);
+                const frame = line(value);
+                if (frame) {
+                    yield frame;
+                    if (frame.event === 'end')
+                        return;
+                }
+            }
+            // An incomplete event at EOF is discarded, as required by SSE framing.
+            if (result.done)
+                return;
+        }
+    }
+    finally {
+        await reader.cancel().catch(() => { });
+        reader.releaseLock();
+    }
+}

package/dist/core/transport.d.ts

@@ -0,0 +1,36 @@
+import { type SSEEvent } from './sse.js';
+export interface PraxisOptions {
+    /** Explicit key. Omitted on a Praxis computer: PRAXIS_API_TOKEN, then ~/.praxis/credentials, are used. */
+    apiKey?: string;
+    baseUrl?: string;
+    timeoutMs?: number;
+    maxRetries?: number;
+    fetch?: typeof globalThis.fetch;
+}
+export interface RequestOptions {
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    timeoutMs?: number;
+    maxRetries?: number;
+}
+export type CallOptions<D> = Omit<D, 'url'> & RequestOptions;
+export type StreamOptions<D> = CallOptions<D> & {
+    lastEventId?: string;
+};
+export type ResponseData<R> = R extends Record<string | number, unknown> ? R[keyof R] : R;
+export type Operation = (options: any) => Promise<any>;
+type InternalOptions = RequestOptions & {
+    body?: unknown;
+    path?: unknown;
+    query?: unknown;
+    lastEventId?: string;
+};
+export declare class Transport {
+    private readonly config;
+    constructor(options: PraxisOptions);
+    private validate;
+    private scope;
+    request<R>(operation: Operation, options?: InternalOptions): Promise<R>;
+    stream<E extends SSEEvent = SSEEvent>(operation: Operation, options?: InternalOptions): AsyncGenerator<E>;
+}
+export {};

package/dist/core/transport.js

@@ -0,0 +1,121 @@
+import { createClient } from "../generated/client/index.js";
+import { PraxisError, PraxisTimeoutError } from "./errors.js";
+import { abortable, fetchWithRetry } from "./retry.js";
+import { parseSSE } from "./sse.js";
+import { resolveDefaultCredentials } from "./credentials.js";
+/** Our own per-call keys, beyond what the generated hey-api client accepts. */
+const SDK_OPTION_KEYS = ['timeoutMs', 'maxRetries', 'stream', 'lastEventId'];
+/** Every key of the generated client's per-call RequestOptions (request parts, fetch/RequestInit, serializers,
+ * auth, SSE hooks, ...). Typed as a total record so a regenerated client that adds a key fails to typecheck here
+ * until the key is classified, instead of being rejected at runtime by the guard below. */
+const HEY_API_OPTION_KEYS = {
+    body: true, path: true, query: true, headers: true, security: true, baseUrl: true, fetch: true, parseAs: true,
+    responseStyle: true, throwOnError: true, auth: true, bodySerializer: true, querySerializer: true,
+    requestValidator: true, responseTransformer: true, responseValidator: true,
+    onRequest: true, onSseError: true, onSseEvent: true, sseDefaultRetryDelay: true, sseMaxRetryAttempts: true, sseMaxRetryDelay: true,
+    // Config extends RequestInit (minus body/headers/method).
+    signal: true, cache: true, credentials: true, integrity: true, keepalive: true, mode: true, priority: true,
+    redirect: true, referrer: true, referrerPolicy: true, window: true,
+};
+const OPTION_KEYS = new Set([...Object.keys(HEY_API_OPTION_KEYS), ...SDK_OPTION_KEYS]);
+/** Client-side guard: flat params like `{ limit: 20 }` would otherwise be silently dropped by the generated client. */
+function assertKnownOptions(options) {
+    if (options === null || typeof options !== 'object')
+        return;
+    const stray = Object.keys(options).filter(key => !OPTION_KEYS.has(key));
+    if (stray.length === 0)
+        return;
+    const names = stray.map(key => `\`${key}\``).join(', ');
+    throw new PraxisError({
+        code: 'INVALID_OPTIONS', param: stray[0],
+        title: 'Invalid options',
+        detail: `Unrecognised option ${stray.length > 1 ? 'keys' : 'key'} ${names}. Request parameters are not flat: put each under \`query\` (GET/DELETE: filters, pagination), \`path\` (URL segments) or \`body\` (POST/PATCH/PUT payload), e.g. call({ query: { ${stray[0]} } }) or call({ body: { ${stray[0]} } }). Common top-level keys: path, query, body, headers, signal, timeoutMs, maxRetries.`,
+    });
+}
+export class Transport {
+    config;
+    constructor(options) {
+        this.config = { timeoutMs: 60_000, maxRetries: 2, fetch: globalThis.fetch, ...options };
+        this.validate(this.config.timeoutMs, this.config.maxRetries);
+    }
+    validate(timeout, retries) {
+        if (!Number.isFinite(timeout) || timeout <= 0)
+            throw new RangeError('timeoutMs must be positive and finite');
+        if (!Number.isSafeInteger(retries) || retries < 0)
+            throw new RangeError('maxRetries must be a non-negative integer');
+    }
+    scope(options, streaming) {
+        assertKnownOptions(options);
+        const timeoutMs = options.timeoutMs ?? this.config.timeoutMs;
+        const maxRetries = options.maxRetries ?? this.config.maxRetries;
+        this.validate(timeoutMs, maxRetries);
+        const controller = new AbortController();
+        const external = options.signal;
+        const abort = () => controller.abort(external?.reason);
+        if (external?.aborted)
+            abort();
+        else
+            external?.addEventListener('abort', abort, { once: true });
+        const timer = setTimeout(() => controller.abort(new PraxisTimeoutError(timeoutMs)), timeoutMs);
+        const signal = controller.signal;
+        // An explicit apiKey wins outright. Otherwise the computer's credentials apply, resolved now so a
+        // renewed token is used; their api_url only applies together with their token.
+        const defaults = this.config.apiKey === undefined ? resolveDefaultCredentials() : {};
+        const apiKey = this.config.apiKey ?? defaults.token;
+        const baseUrl = this.config.baseUrl ?? defaults.apiUrl ?? 'https://api.deepraxis.com';
+        const headers = new Headers(apiKey ? { 'X-API-Key': apiKey, Authorization: `Bearer ${apiKey}` } : {});
+        for (const [name, value] of Object.entries(options.headers ?? {}))
+            headers.set(name, value);
+        if (streaming)
+            headers.set('Accept', 'text/event-stream');
+        if (options.lastEventId !== undefined)
+            headers.set('Last-Event-ID', options.lastEventId);
+        const client = createClient({ baseUrl: baseUrl.replace(/\/$/, ''), headers, throwOnError: true,
+            fetch: ((request) => fetchWithRetry(request, this.config.fetch, { signal, maxRetries })),
+        });
+        client.interceptors.error.use((error, response) => {
+            if (signal.aborted)
+                return signal.reason;
+            if (error instanceof PraxisError)
+                return error;
+            return response && !response.ok ? PraxisError.fromResponse(response, error) : error;
+        });
+        if (streaming) {
+            // Pure SSE generated functions call client.sse.<verb>. Route those through
+            // the same generated Fetch client, preserving serialization and our policy.
+            client.sse = Object.fromEntries(['get', 'post', 'put', 'patch', 'delete', 'head', 'options', 'trace', 'connect'].map(method => [method, client[method]]));
+        }
+        return {
+            signal,
+            options: { ...options, headers: Object.fromEntries(headers), client, signal, throwOnError: true, responseStyle: 'fields', ...(streaming ? { parseAs: 'stream' } : {}) },
+            close() { clearTimeout(timer); external?.removeEventListener('abort', abort); },
+        };
+    }
+    async request(operation, options = {}) {
+        const scope = this.scope(options, false);
+        try {
+            return (await abortable(operation(scope.options), scope.signal)).data;
+        }
+        finally {
+            scope.close();
+        }
+    }
+    async *stream(operation, options = {}) {
+        const scope = this.scope(options, true);
+        try {
+            const result = await abortable(operation(scope.options), scope.signal);
+            if (!result.response.headers.get('content-type')?.split(';')[0]?.trim().toLowerCase().includes('text/event-stream')) {
+                await result.response.body?.cancel();
+                throw new PraxisError({ status: result.response.status, code: 'INVALID_RESPONSE', title: 'Expected text/event-stream' });
+            }
+            if (!result.data)
+                throw new PraxisError({ code: 'INVALID_RESPONSE', title: 'Missing SSE response body' });
+            // Types come from the spec's envelope; like the generated client this does
+            // not perform runtime schema validation of server payloads.
+            yield* parseSSE(result.data, { signal: scope.signal, lastEventId: options.lastEventId });
+        }
+        finally {
+            scope.close();
+        }
+    }
+}

package/dist/generated/client/client.gen.d.ts

@@ -0,0 +1,2 @@
+import type { Client, Config } from './types.gen.js';
+export declare const createClient: (config?: Config) => Client;

package/dist/generated/client/client.gen.js

@@ -0,0 +1,216 @@
+// This file is auto-generated by @hey-api/openapi-ts
+import { createSseClient } from '../core/serverSentEvents.gen.js';
+import { getValidRequestBody } from '../core/utils.gen.js';
+import { buildUrl, createConfig, createInterceptors, getParseAs, mergeConfigs, mergeHeaders, setAuthParams, } from './utils.gen.js';
+export const createClient = (config = {}) => {
+    let _config = mergeConfigs(createConfig(), config);
+    const getConfig = () => ({ ..._config });
+    const setConfig = (config) => {
+        _config = mergeConfigs(_config, config);
+        return getConfig();
+    };
+    const interceptors = createInterceptors();
+    const beforeRequest = async (options) => {
+        const opts = {
+            ..._config,
+            ...options,
+            fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+            headers: mergeHeaders(_config.headers, options.headers),
+            serializedBody: undefined,
+        };
+        if (opts.security) {
+            await setAuthParams(opts);
+        }
+        if (opts.requestValidator) {
+            await opts.requestValidator(opts);
+        }
+        if (opts.body !== undefined && opts.bodySerializer) {
+            opts.serializedBody = opts.bodySerializer(opts.body);
+        }
+        // remove Content-Type header if body is empty to avoid sending invalid requests
+        if (opts.body === undefined || opts.serializedBody === '') {
+            opts.headers.delete('Content-Type');
+        }
+        const resolvedOpts = opts;
+        const url = buildUrl(resolvedOpts);
+        return { opts: resolvedOpts, url };
+    };
+    const request = async (options) => {
+        const throwOnError = options.throwOnError ?? _config.throwOnError;
+        const responseStyle = options.responseStyle ?? _config.responseStyle;
+        let request;
+        let response;
+        try {
+            const { opts, url } = await beforeRequest(options);
+            const requestInit = {
+                redirect: 'follow',
+                ...opts,
+                body: getValidRequestBody(opts),
+            };
+            request = new Request(url, requestInit);
+            for (const fn of interceptors.request.fns) {
+                if (fn) {
+                    request = await fn(request, opts);
+                }
+            }
+            // fetch must be assigned here, otherwise it would throw the error:
+            // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+            const _fetch = opts.fetch;
+            response = await _fetch(request);
+            for (const fn of interceptors.response.fns) {
+                if (fn) {
+                    response = await fn(response, request, opts);
+                }
+            }
+            const result = {
+                request,
+                response,
+            };
+            if (response.ok) {
+                const parseAs = (opts.parseAs === 'auto'
+                    ? getParseAs(response.headers.get('Content-Type'))
+                    : opts.parseAs) ?? 'json';
+                if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+                    let emptyData;
+                    switch (parseAs) {
+                        case 'arrayBuffer':
+                        case 'blob':
+                        case 'text':
+                            emptyData = await response[parseAs]();
+                            break;
+                        case 'formData':
+                            emptyData = new FormData();
+                            break;
+                        case 'stream':
+                            emptyData = response.body;
+                            break;
+                        case 'json':
+                        default:
+                            emptyData = {};
+                            break;
+                    }
+                    return opts.responseStyle === 'data'
+                        ? emptyData
+                        : {
+                            data: emptyData,
+                            ...result,
+                        };
+                }
+                let data;
+                switch (parseAs) {
+                    case 'arrayBuffer':
+                    case 'blob':
+                    case 'formData':
+                    case 'text':
+                        data = await response[parseAs]();
+                        break;
+                    case 'json': {
+                        // Some servers return 200 with no Content-Length and empty body.
+                        // response.json() would throw; read as text and parse if non-empty.
+                        const text = await response.text();
+                        data = text ? JSON.parse(text) : {};
+                        break;
+                    }
+                    case 'stream':
+                        return opts.responseStyle === 'data'
+                            ? response.body
+                            : {
+                                data: response.body,
+                                ...result,
+                            };
+                }
+                if (parseAs === 'json') {
+                    if (opts.responseValidator) {
+                        await opts.responseValidator(data);
+                    }
+                    if (opts.responseTransformer) {
+                        data = await opts.responseTransformer(data);
+                    }
+                }
+                return opts.responseStyle === 'data'
+                    ? data
+                    : {
+                        data,
+                        ...result,
+                    };
+            }
+            const textError = await response.text();
+            let jsonError;
+            try {
+                jsonError = JSON.parse(textError);
+            }
+            catch {
+                // noop
+            }
+            throw jsonError ?? textError;
+        }
+        catch (error) {
+            let finalError = error;
+            for (const fn of interceptors.error.fns) {
+                if (fn) {
+                    finalError = await fn(finalError, response, request, options);
+                }
+            }
+            finalError = finalError || {};
+            if (throwOnError) {
+                throw finalError;
+            }
+            // TODO: we probably want to return error and improve types
+            return responseStyle === 'data'
+                ? undefined
+                : {
+                    error: finalError,
+                    request,
+                    response,
+                };
+        }
+    };
+    const makeMethodFn = (method) => (options) => request({ ...options, method });
+    const makeSseFn = (method) => async (options) => {
+        const { opts, url } = await beforeRequest(options);
+        return createSseClient({
+            ...opts,
+            body: opts.body,
+            method,
+            onRequest: async (url, init) => {
+                let request = new Request(url, init);
+                for (const fn of interceptors.request.fns) {
+                    if (fn) {
+                        request = await fn(request, opts);
+                    }
+                }
+                return request;
+            },
+            serializedBody: getValidRequestBody(opts),
+            url,
+        });
+    };
+    const _buildUrl = (options) => buildUrl({ ..._config, ...options });
+    return {
+        buildUrl: _buildUrl,
+        connect: makeMethodFn('CONNECT'),
+        delete: makeMethodFn('DELETE'),
+        get: makeMethodFn('GET'),
+        getConfig,
+        head: makeMethodFn('HEAD'),
+        interceptors,
+        options: makeMethodFn('OPTIONS'),
+        patch: makeMethodFn('PATCH'),
+        post: makeMethodFn('POST'),
+        put: makeMethodFn('PUT'),
+        request,
+        setConfig,
+        sse: {
+            connect: makeSseFn('CONNECT'),
+            delete: makeSseFn('DELETE'),
+            get: makeSseFn('GET'),
+            head: makeSseFn('HEAD'),
+            options: makeSseFn('OPTIONS'),
+            patch: makeSseFn('PATCH'),
+            post: makeSseFn('POST'),
+            put: makeSseFn('PUT'),
+            trace: makeSseFn('TRACE'),
+        },
+        trace: makeMethodFn('TRACE'),
+    };
+};