@inferencesh/sdk 0.20.1 → 0.22.0

package/dist/http/client.js

@@ -1,5 +1,6 @@
 import { InferenceError, RequirementsNotMetException } from './errors';
 import { EventSource } from 'eventsource';
+import { SDK_VERSION } from '../version';
 /**
  * Low-level HTTP client for inference.sh API
  *
@@ -16,7 +17,7 @@ export class HttpClient {
         this.baseUrl = config.baseUrl || 'https://api.inference.sh';
         this.proxyUrl = config.proxyUrl;
         this.getToken = config.getToken;
-        this.customHeaders = { 'X-Client-Source': 'inference-sdk-js/0.5.13', ...config.headers };
+        this.customHeaders = { 'X-Client-Source': `inference-sdk-js/${SDK_VERSION}`, ...config.headers };
         // Bearer auth needs no cookies, and 'include' makes browsers reject the
         // response unless the API answers with Allow-Credentials — which it does not
         // for third-party origins (WebKit reports that as "Load failed"). Cookies
@@ -54,32 +55,139 @@ export class HttpClient {
         }
         return resolved;
     }
-    /** Get authorization token */
-    getAuthToken() {
-        if (this.getToken) {
-            return this.getToken();
+    /** The bearer token a request sent now carries; none through a proxy, which adds its own. */
+    async bearerToken() {
+        if (this.proxyUrl)
+            return undefined;
+        return (this.getToken ? await this.getToken() : this.apiKey) || undefined;
+    }
+    /** The configured headers plus what identifies the request: its bearer, or through a proxy its target. */
+    requestHeaders(targetUrl, token) {
+        const headers = this.resolveHeaders();
+        if (this.proxyUrl) {
+            headers['x-inf-target-url'] = targetUrl.toString();
+        }
+        else if (token) {
+            headers['Authorization'] = `Bearer ${token}`;
         }
-        return this.apiKey;
+        return headers;
+    }
+    /**
+     * Where a request whose caller cannot set headers (EventSource) or reads
+     * the URL (streams) goes: the API, or the proxy with the target as a query
+     * parameter.
+     */
+    streamUrl(targetUrl) {
+        if (!this.proxyUrl)
+            return targetUrl.toString();
+        const proxyUrlWithQuery = new URL(this.proxyUrl, typeof window !== 'undefined' ? window.location.origin : 'http://localhost');
+        proxyUrlWithQuery.searchParams.set('__inf_target', targetUrl.toString());
+        return proxyUrlWithQuery.toString();
     }
     /**
      * Make an HTTP request to the API
      */
-    async request(method, endpoint, options = {}) {
-        const doRequest = () => this.executeRequest(method, endpoint, options);
+    async request(method, endpoint, { handleErrors = true, ...options } = {}) {
+        const send = (token) => this.executeRequest(method, endpoint, options, token);
+        const token = await this.bearerToken();
         try {
-            return await doRequest();
+            return await send(token);
         }
         catch (error) {
-            if (this.onError) {
-                return await this.onError(error, doRequest);
+            if (this.onError && handleErrors) {
+                return await this.onError(error, async () => send(await this.bearerToken()), { token });
             }
             throw error;
         }
     }
+    /**
+     * Fetch an API endpoint with the client's auth, headers and credentials
+     * mode and resolve with the raw response, for bodies request() does not
+     * parse (streams, text). A failure goes through onError like one of
+     * request() does: a refused response, or a request that got no response.
+     * It resolves with the response onError's retry got; when onError resolves
+     * with anything else the failure stands and is thrown, the error request()
+     * would throw. A request aborted through `init.signal` rejects with the
+     * abort and is not an error for onError.
+     */
+    async fetch(endpoint, init = {}) {
+        const targetUrl = new URL(`${this.baseUrl}${endpoint}`);
+        const response = await this.fetchHandled(this.streamUrl(targetUrl), targetUrl, init, 'throw');
+        // What onError's retry got is handed over unread, and can be a refusal too.
+        if (!response.ok)
+            throw await this.readError(response);
+        return response;
+    }
+    /**
+     * One fetch of `url` on behalf of `targetUrl`. A refused response, or a
+     * request that got none, goes to onError; the result is the response its
+     * retry got. Without one the failure stands: the error of a request that
+     * got no response is thrown, and a refusal is thrown as the error its body
+     * was read into or, for a caller that passes the response on
+     * (`refused: 'return'`), handed back with its body unread.
+     */
+    async fetchHandled(url, targetUrl, init, refused) {
+        const send = (token) => fetch(url, {
+            ...init,
+            headers: { ...init.headers, ...this.requestHeaders(targetUrl, token) },
+            credentials: this.credentials,
+        });
+        const retry = async () => send(await this.bearerToken());
+        const token = await this.bearerToken();
+        let response;
+        try {
+            response = await send(token);
+        }
+        catch (error) {
+            // The caller aborted the request; nothing failed.
+            if (!this.onError || init.signal?.aborted)
+                throw error;
+            const handled = await this.onError(error, retry, { token });
+            if (handled instanceof globalThis.Response)
+                return handled;
+            throw error;
+        }
+        if (response.ok || (refused === 'return' && !this.onError))
+            return response;
+        // The body is read once: from a clone only when the response is handed back.
+        const error = await this.readError(refused === 'return' ? response.clone() : response);
+        const handled = await this.onError?.(error, retry, { token });
+        if (handled instanceof globalThis.Response)
+            return handled;
+        if (refused === 'return')
+            return response;
+        throw error;
+    }
+    /** The error a refused response stands for, read from its body. */
+    async readError(response) {
+        const responseText = await response.text().catch(() => '');
+        let data = null;
+        try {
+            data = JSON.parse(responseText);
+        }
+        catch {
+            // Not JSON
+        }
+        return this.responseError(response.status, responseText, data);
+    }
+    /** HTTP errors → RFC 9457 problem+json */
+    responseError(status, responseText, data) {
+        if (status === 412 && data && typeof data === 'object' && 'errors' in data && Array.isArray(data.errors)) {
+            return RequirementsNotMetException.fromResponse(data, status);
+        }
+        let errorDetail;
+        if (data && typeof data === 'object') {
+            errorDetail = this.extractErrorDetail(data) ?? JSON.stringify(data);
+        }
+        else if (responseText) {
+            errorDetail = responseText.slice(0, 500);
+        }
+        return new InferenceError(status, errorDetail || 'Request failed', responseText);
+    }
     /**
      * Execute the actual HTTP request (internal)
      */
-    async executeRequest(method, endpoint, options = {}) {
+    async executeRequest(method, endpoint, options, token) {
         // Build the target URL (always points to the API)
         const targetUrl = new URL(`${this.baseUrl}${endpoint}`);
         if (options.params) {
@@ -92,23 +200,11 @@ export class HttpClient {
             });
         }
         // In proxy mode, requests go to the proxy with target URL in a header
-        const isProxyMode = !!this.proxyUrl;
-        const fetchUrl = isProxyMode ? this.proxyUrl : targetUrl.toString();
+        const fetchUrl = this.proxyUrl ?? targetUrl.toString();
         const headers = {
             'Content-Type': 'application/json',
-            ...this.resolveHeaders(),
+            ...this.requestHeaders(targetUrl, token),
         };
-        if (isProxyMode) {
-            // Proxy mode: send target URL as header, no auth (proxy handles it)
-            headers['x-inf-target-url'] = targetUrl.toString();
-        }
-        else {
-            // Direct mode: include authorization header
-            const token = this.getAuthToken();
-            if (token) {
-                headers['Authorization'] = `Bearer ${token}`;
-            }
-        }
         const fetchOptions = {
             method: method.toUpperCase(),
             headers,
@@ -126,19 +222,8 @@ export class HttpClient {
         catch {
             // Not JSON
         }
-        // HTTP errors → RFC 9457 problem+json
         if (!response.ok) {
-            if (response.status === 412 && data && 'errors' in data && Array.isArray(data.errors)) {
-                throw RequirementsNotMetException.fromResponse(data, response.status);
-            }
-            let errorDetail;
-            if (data && typeof data === 'object') {
-                errorDetail = this.extractErrorDetail(data) ?? JSON.stringify(data);
-            }
-            else if (responseText) {
-                errorDetail = responseText.slice(0, 500);
-            }
-            throw new InferenceError(response.status, errorDetail || 'Request failed', responseText);
+            throw this.responseError(response.status, responseText, data);
         }
         if (response.status === 204 || !responseText) {
             return { data: undefined, messages: [] };
@@ -156,26 +241,22 @@ export class HttpClient {
     /**
      * Get URL and headers for NDJSON streaming.
      * Returns the full URL and auth headers needed for streamable requests.
+     * It answers synchronously, so it throws when getToken is async.
+     * @deprecated Use fetch(), or a StreamRequest built on it
+     * (`(init) => http.fetch(endpoint, init)`): a request made from this config
+     * bypasses onError and carries the token of the moment the config was read.
      */
     getStreamableConfig(endpoint) {
         const targetUrl = new URL(`${this.baseUrl}${endpoint}`);
-        const isProxyMode = !!this.proxyUrl;
-        let url;
-        const headers = { ...this.resolveHeaders() };
-        if (isProxyMode) {
-            const proxyUrlWithQuery = new URL(this.proxyUrl, typeof window !== 'undefined' ? window.location.origin : 'http://localhost');
-            proxyUrlWithQuery.searchParams.set('__inf_target', targetUrl.toString());
-            url = proxyUrlWithQuery.toString();
-            headers['x-inf-target-url'] = targetUrl.toString();
-        }
-        else {
-            url = targetUrl.toString();
-            const token = this.getAuthToken();
-            if (token) {
-                headers['Authorization'] = `Bearer ${token}`;
-            }
+        const token = this.proxyUrl ? undefined : this.getToken ? this.getToken() : this.apiKey;
+        if (token instanceof Promise) {
+            throw new Error('getStreamableConfig() cannot wait for an async getToken; use fetch() instead');
         }
-        return { url, headers, credentials: this.credentials };
+        return {
+            url: this.streamUrl(targetUrl),
+            headers: this.requestHeaders(targetUrl, token || undefined),
+            credentials: this.credentials,
+        };
     }
     /**
      * Pull a human-readable detail string from a parsed problem+json / API error
@@ -189,56 +270,16 @@ export class HttpClient {
     }
     /**
      * Create an EventSource for SSE streaming
-     * @deprecated Use getStreamableConfig() with StreamableManager instead
+     * @deprecated Use StreamableManager with a StreamRequest instead
      */
     createEventSource(endpoint) {
         const targetUrl = new URL(`${this.baseUrl}${endpoint}`);
-        const isProxyMode = !!this.proxyUrl;
-        // For proxy mode: Browser EventSource can't send custom headers,
-        // so append target URL as query param instead
-        let fetchUrl;
-        if (isProxyMode) {
-            const proxyUrlWithQuery = new URL(this.proxyUrl, typeof window !== 'undefined' ? window.location.origin : 'http://localhost');
-            proxyUrlWithQuery.searchParams.set('__inf_target', targetUrl.toString());
-            fetchUrl = proxyUrlWithQuery.toString();
-        }
-        else {
-            fetchUrl = targetUrl.toString();
-        }
-        const resolvedHeaders = this.resolveHeaders();
         // The EventSource error event omits the response body, so a failed initial
         // connection (e.g. 403 otp_required) is handled here in the fetch wrapper:
         // route it through onError like request() does, and hand the retried
         // response (e.g. after OTP verification) back so the stream connects.
-        const doFetch = async (input, init) => {
-            const headers = {
-                ...init?.headers,
-                ...resolvedHeaders,
-            };
-            if (isProxyMode) {
-                headers['x-inf-target-url'] = targetUrl.toString();
-            }
-            else {
-                const token = this.getAuthToken();
-                if (token) {
-                    headers['Authorization'] = `Bearer ${token}`;
-                }
-            }
-            const response = await fetch(input, { ...init, headers, credentials: this.credentials });
-            if (!response.ok && this.onError) {
-                const body = await response.clone().text().catch(() => '');
-                let data;
-                try {
-                    data = JSON.parse(body);
-                }
-                catch { /* non-JSON body */ }
-                const error = new InferenceError(response.status, this.extractErrorDetail(data) ?? 'Request failed', body);
-                const handled = await this.onError(error, () => doFetch(input, init));
-                return handled ?? response;
-            }
-            return response;
-        };
-        return Promise.resolve(new EventSource(fetchUrl, { fetch: doFetch }));
+        const doFetch = (input, init) => this.fetchHandled(input, targetUrl, init ?? {}, 'return');
+        return Promise.resolve(new EventSource(this.streamUrl(targetUrl), { fetch: doFetch }));
     }
 }
 /**

package/dist/http/index.d.ts

@@ -1,4 +1,4 @@
-export { HttpClient, type HttpClientConfig, type ErrorHandler, createHttpClient } from './client';
+export { HttpClient, type HttpClientConfig, type ErrorHandler, type FailedRequest, type HttpFetchInit, createHttpClient } from './client';
 export { StreamManager, type StreamManagerOptions, type PartialDataWrapper } from './stream';
-export { streamable, streamableRaw, StreamableManager, type StreamableOptions, type StreamableMessage, type StreamableManagerOptions } from './streamable';
+export { streamable, streamableRaw, StreamableManager, type StreamableOptions, type StreamableMessage, type StreamableManagerOptions, type StreamableSource, type StreamRequest, type StreamRequestInit } from './streamable';
 export { InferenceError, RequirementsNotMetException } from './errors';

package/dist/http/loopback.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Loopback hosts, where plain http never leaves the machine (local dev):
+ * `localhost`, any `*.localhost`, `[::1]` and 127.0.0.0/8. This is the one
+ * copy of the rule; the proxy, the app and common-js all ask it.
+ */
+export declare function isLoopbackHost(hostname: string): boolean;
+/** Whether `url` is https, or plain http to a loopback host. */
+export declare function isHttpsOrLoopback(url: URL): boolean;

package/dist/http/loopback.js

@@ -0,0 +1,18 @@
+/**
+ * Loopback hosts, where plain http never leaves the machine (local dev):
+ * `localhost`, any `*.localhost`, `[::1]` and 127.0.0.0/8. This is the one
+ * copy of the rule; the proxy, the app and common-js all ask it.
+ */
+export function isLoopbackHost(hostname) {
+    const h = hostname.toLowerCase();
+    return h === 'localhost'
+        || h.endsWith('.localhost')
+        || h === '[::1]'
+        || /^127(\.\d{1,3}){3}$/.test(h);
+}
+/** Whether `url` is https, or plain http to a loopback host. */
+export function isHttpsOrLoopback(url) {
+    if (url.protocol === 'https:')
+        return true;
+    return url.protocol === 'http:' && isLoopbackHost(url.hostname);
+}

package/dist/http/stream-until-terminal.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Follow a resource's NDJSON stream until the resource reaches a terminal
+ * state.
+ *
+ * StreamableManager never reconnects, and a stream can close cleanly before
+ * the resource is done (load balancer idle timeout, API deploy). A wait built
+ * on it must not hang then. This helper owns that contract for every
+ * "stream until done" wait: when the stream ends early it fetches the
+ * resource once (`reconcile`) and settles with what that shows, or rejects
+ * when the resource is still not terminal. sdk-py's `wait_for_completion`
+ * does the same final GET.
+ */
+import { type StreamableManagerOptions, type StreamRequest } from './streamable';
+/** Settles a stream-until-terminal wait. Calls after the first are ignored. */
+export interface TerminalSettler<R> {
+    resolve(value: R): void;
+    reject(error: Error): void;
+}
+/** The stream to follow and how to tell when its resource is done. */
+export type StreamUntilTerminalSpec<T> = Pick<StreamableManagerOptions<T>, 'body' | 'onData' | 'onPartialData' | 'onStart' | 'onDelta'> & {
+    /** Sends the stream request, e.g. `(init) => http.fetch(endpoint, init)`. */
+    request: StreamRequest;
+    /** Typed event listeners ({"event": name, "data": ...} messages). */
+    events?: Record<string, (data: any, fields?: string[]) => void>;
+    /**
+     * Called once when the stream ends cleanly before the wait settled. Fetch
+     * the resource and settle if it is terminal; returning without settling
+     * rejects the wait with `closedMessage`.
+     */
+    reconcile: () => Promise<void>;
+    /** Rejection message when the stream closed and the resource is still not terminal. */
+    closedMessage: string;
+    /**
+     * Called when the wait ends because `stop()` was called. Without it `done`
+     * stays pending.
+     */
+    onStopped?: () => void;
+    /**
+     * Keep the stream open after the wait settled so its listeners go on
+     * seeing updates (default false: settling stops the stream).
+     */
+    keepOpen?: boolean;
+};
+export interface StreamUntilTerminal<R> {
+    /** Settles when the resource is terminal, the stream fails, or it closed early and the resource is not terminal. */
+    done: Promise<R>;
+    /** Ends the stream on purpose; see `onStopped`. */
+    stop(): void;
+}
+/**
+ * `build` receives the settler and returns the stream spec; its handlers call
+ * `settle.resolve`/`settle.reject` once the resource is terminal. Settling
+ * stops the stream unless the spec says `keepOpen`.
+ */
+export declare function streamUntilTerminal<T, R>(build: (settle: TerminalSettler<R>) => StreamUntilTerminalSpec<T>): StreamUntilTerminal<R>;

package/dist/http/stream-until-terminal.js

@@ -0,0 +1,88 @@
+/**
+ * Follow a resource's NDJSON stream until the resource reaches a terminal
+ * state.
+ *
+ * StreamableManager never reconnects, and a stream can close cleanly before
+ * the resource is done (load balancer idle timeout, API deploy). A wait built
+ * on it must not hang then. This helper owns that contract for every
+ * "stream until done" wait: when the stream ends early it fetches the
+ * resource once (`reconcile`) and settles with what that shows, or rejects
+ * when the resource is still not terminal. sdk-py's `wait_for_completion`
+ * does the same final GET.
+ */
+import { StreamableManager } from './streamable';
+/**
+ * `build` receives the settler and returns the stream spec; its handlers call
+ * `settle.resolve`/`settle.reject` once the resource is terminal. Settling
+ * stops the stream unless the spec says `keepOpen`.
+ */
+export function streamUntilTerminal(build) {
+    let settled = false;
+    let stopped = false;
+    let manager;
+    const done = new Promise((resolve, reject) => {
+        const settle = {
+            resolve: (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (!keepOpen)
+                    manager?.stop();
+                resolve(value);
+            },
+            reject: (error) => {
+                if (settled)
+                    return;
+                settled = true;
+                if (!keepOpen)
+                    manager?.stop();
+                reject(error);
+            },
+        };
+        const { events, reconcile, closedMessage, onStopped, keepOpen, ...managerOptions } = build(settle);
+        let streamError = null;
+        manager = new StreamableManager({
+            ...managerOptions,
+            onError: (error) => {
+                streamError = error;
+            },
+            onEnd: () => {
+                if (settled)
+                    return;
+                if (stopped) {
+                    onStopped?.();
+                    return;
+                }
+                if (streamError) {
+                    settle.reject(streamError);
+                    return;
+                }
+                // Closed cleanly before the resource was terminal: ask the API once.
+                const closed = (cause) => {
+                    if (stopped && !settled) {
+                        onStopped?.();
+                        return;
+                    }
+                    const error = new Error(closedMessage);
+                    if (cause !== undefined)
+                        error.cause = cause;
+                    settle.reject(error);
+                };
+                reconcile().then(() => closed(), closed);
+            },
+        });
+        for (const [name, listener] of Object.entries(events ?? {})) {
+            manager.addEventListener(name, listener);
+        }
+    });
+    manager.start();
+    return {
+        done,
+        stop: () => {
+            if (stopped)
+                return;
+            stopped = true;
+            manager.stop();
+        },
+    };
+}

package/dist/http/stream.d.ts

@@ -24,6 +24,7 @@ export declare class StreamManager<T> {
     private initialConnectionAttempts;
     private consecutiveErrors;
     private isConnected;
+    private hasEverConnected;
     private isStopped;
     private eventListeners;
     constructor(options: StreamManagerOptions<T>);

package/dist/http/stream.js

@@ -17,6 +17,7 @@ export class StreamManager {
         this.initialConnectionAttempts = 0;
         this.consecutiveErrors = 0;
         this.isConnected = false;
+        this.hasEverConnected = false;
         this.isStopped = false;
         this.eventListeners = new Map();
         this.options = {
@@ -53,6 +54,8 @@ export class StreamManager {
         source.addEventListener(eventName, (e) => {
             if (this.isStopped)
                 return;
+            // A delivered event proves the connection works, same as onmessage.
+            this.consecutiveErrors = 0;
             try {
                 const parsed = JSON.parse(e.data);
                 const listeners = this.eventListeners.get(eventName);
@@ -114,15 +117,15 @@ export class StreamManager {
         if (!this.options.autoReconnect || this.isStopped)
             return false;
         const maxReconnects = this.options.maxReconnects ?? 5;
-        if (!this.isConnected && this.initialConnectionAttempts >= maxReconnects) {
+        if (!this.hasEverConnected && this.initialConnectionAttempts >= maxReconnects) {
             return false;
         }
-        if (this.isConnected && this.consecutiveErrors >= maxReconnects) {
+        if (this.hasEverConnected && this.consecutiveErrors >= maxReconnects) {
             return false;
         }
         this.reconnectTimeout = setTimeout(() => {
             if (!this.isStopped) {
-                if (!this.isConnected) {
+                if (!this.hasEverConnected) {
                     this.initialConnectionAttempts++;
                 }
                 this.consecutiveErrors++;
@@ -142,6 +145,7 @@ export class StreamManager {
                 return;
             this.eventSource = source;
             this.isConnected = true;
+            this.hasEverConnected = true;
             this.options.onStart?.();
             // Set up typed event listeners (for events with `event: eventName` header)
             this.setupAllEventListeners(source);

package/dist/http/streamable.d.ts

@@ -3,6 +3,19 @@
  * This is the NDJSON alternative to SSE/EventSource that avoids
  * the browser's ~6 connection limit per domain.
  */
+/** What a stream asks of whatever sends its request. */
+export interface StreamRequestInit {
+    method: 'GET' | 'POST';
+    headers: Record<string, string>;
+    body?: string;
+    signal?: AbortSignal;
+}
+/**
+ * Sends a stream's request in place of a plain fetch of a URL. With
+ * `(init) => http.fetch(endpoint, init)` the request carries the client's
+ * auth and a refusal goes through its error handler.
+ */
+export type StreamRequest = (init: StreamRequestInit) => Promise<Response>;
 export interface StreamableOptions {
     /** Additional headers to include */
     headers?: Record<string, string>;
@@ -14,7 +27,7 @@ export interface StreamableOptions {
     signal?: AbortSignal;
     /** Skip heartbeat messages (default: true) */
     skipHeartbeats?: boolean;
-    /** Request credentials mode (for cookie-based auth) */
+    /** Request credentials mode (for cookie-based auth); a StreamRequest brings its own */
     credentials?: RequestCredentials;
 }
 export interface StreamableMessage<T = unknown> {
@@ -30,19 +43,26 @@ export interface StreamableMessage<T = unknown> {
 /**
  * Stream NDJSON from an HTTP endpoint using fetch + ReadableStream.
  * Yields parsed JSON objects, automatically filtering heartbeats.
+ * `source` is the URL to fetch, or a StreamRequest that sends the request.
  */
-export declare function streamable<T = unknown>(url: string, options?: StreamableOptions): AsyncGenerator<T>;
+export declare function streamable<T = unknown>(source: string | StreamRequest, options?: StreamableOptions): AsyncGenerator<T>;
 /**
  * StreamableManager provides a callback-based API similar to StreamManager
  * but uses fetch + ReadableStream instead of EventSource.
  */
-export interface StreamableManagerOptions<T> {
+/** Where a StreamableManager's stream comes from: a URL it fetches, or a StreamRequest. */
+export type StreamableSource = {
     /** URL to connect to */
     url: string;
     /** Additional headers */
     headers?: Record<string, string>;
     /** Request credentials mode (for cookie-based auth) */
     credentials?: RequestCredentials;
+} | {
+    /** Sends the request, e.g. `(init) => http.fetch(endpoint, init)` */
+    request: StreamRequest;
+};
+export type StreamableManagerOptions<T> = StreamableSource & {
     /** Request body */
     body?: unknown;
     /** Called for each message */
@@ -57,7 +77,7 @@ export interface StreamableManagerOptions<T> {
     onEnd?: () => void;
     /** Called for delta events (streaming token deltas) */
     onDelta?: (delta: Record<string, any>, seq: number) => void;
-}
+};
 export declare class StreamableManager<T> {
     private options;
     private abortController;
@@ -76,4 +96,4 @@ export declare class StreamableManager<T> {
  * Raw streamable that yields the full message including wrapper.
  * Use this when you need access to event type or fields.
  */
-export declare function streamableRaw<T = unknown>(url: string, options?: StreamableOptions): AsyncGenerator<StreamableMessage<T> | T>;
+export declare function streamableRaw<T = unknown>(source: string | StreamRequest, options?: StreamableOptions): AsyncGenerator<StreamableMessage<T> | T>;