@inferencesh/sdk 0.20.1 → 0.21.0

package/CHANGELOG.md

@@ -7,6 +7,63 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.21.0] - 2026-10-08
+
+Breaking: `AgentClient.http` requires `fetch`, the `AppTag*` constants are removed, and `StreamableManagerOptions` is a type alias. See Changed and Removed.
+
+### Added
+
+- `HttpClient.fetch(endpoint, init?)`: fetches an endpoint with the client's auth, headers and credentials mode and resolves with the raw `Response`, for bodies `request()` does not parse (streams, text). A refused response throws the error `request()` would (`InferenceError`, `RequirementsNotMetException`). Type `HttpFetchInit`.
+- `StreamRequest` and `StreamRequestInit`: a function that sends a stream's request. `StreamableManager` takes `{ request }` in place of `{ url, headers, credentials }`, and `streamable()` / `streamableRaw()` take one in place of the URL. With `(init) => http.fetch(endpoint, init)` the stream carries the token of the moment it connects and a refusal goes through `onError`. Type `StreamableSource`.
+- `onError` gets a third argument, `FailedRequest` (`{ token }`): the bearer token the failed request carried, so a handler that refreshes credentials can tell a request sent before the refresh from one sent after it.
+- `getToken` may be async (`() => string | null | undefined | Promise<string | null | undefined>`). `request()`, `fetch()` and the EventSource handshake wait for it.
+- `HttpClient.request()` takes `handleErrors` (default `true`). With `handleErrors: false` the caller handles the request's failure itself: `onError` is not called for it, nothing is retried, and the error is thrown as it is.
+
+- Types: `StoreCategoryDTO` and `StoreTagDTO` (`GET /store/categories`, `GET /store/tags`); the decision app contract (`DecisionInput`, `DecisionVisionInput`, `DecisionOutput` and its question and answer types); `ErrorCodeImpersonationReasonRequired`.
+
+### Changed
+
+- `AgentClient.http` requires `fetch` and no longer requires `getStreamableConfig`. A hand-built `AgentClient` must add `http.fetch`; `Inference` and `HttpClient` already have it.
+- The streams the SDK opens itself (`tasks.run()` and `tasks.watch()`, `Agent` chat streams, the agent chat in `@inferencesh/sdk/agent`) go through `HttpClient.fetch`. A stream the api refuses now reaches `onError` like a refused request, and fails with an `InferenceError` (`statusCode`, `responseBody`) where it failed with `Error('HTTP <status>: <body>')`.
+- A request that got no response (the network failed) goes to `onError` from `fetch()` and the EventSource handshake too, as it already did from `request()`. The failure is thrown unless the handler's retry resolves with a response. A request aborted through its signal is not handed to `onError`.
+- The EventSource handshake and `fetch()` take what `onError` resolves with only when it is a `Response`; anything else leaves the refused response in place.
+- `StreamableManagerOptions` is a type alias (`StreamableSource & { ... }`), no longer an interface: it cannot be extended with `interface X extends StreamableManagerOptions<T>`; use an intersection.
+
+### Removed
+
+- The `AppTag*` constants (`AppTagTextToImage` and the rest). App tags come from the store: `GET /store/tags`, typed `StoreTagDTO`.
+
+### Deprecated
+
+- `HttpClient.getStreamableConfig()`: a request made from the config bypasses `onError` and carries the token of the moment the config was read. Use `fetch()` or a `StreamRequest`. It throws when `getToken` is async.
+
+## [0.20.1] - 2026-10-08
+
+### Added
+
+- Types: app tags and the decision app category.
+
+## [0.20.0] - 2026-10-07
+
+### Added
+
+- `tasks.files(id)`, `tasks.deleteFiles(id)` and `tasks.delete(id, { files })`: list a task's files and delete them with or without the task.
+- Types: task files, MCP Apps (`_meta.ui`, `AppUIRef`, the MCP tool call UI fields), remote tags and policy rules, `AppDTO.resolved_function`, `DescriptionLimit`.
+
+### Changed
+
+- Types: forms lose the bounty and reward fields; a bounty's proof form drops `proof_min_length`.
+
+### Security
+
+- `next` ^16.3.6 (resolves 16.3.8) for GHSA-vcvr-r3jv-pc5j.
+
+## [0.19.0] - 2026-10-04
+
+### Changed
+
+- Types regenerated; the run parameters docs drop `params.variant`.
+
 ## [0.18.0] - 2026-10-04
 
 ### Added

package/dist/agent/actions.js

@@ -109,11 +109,8 @@ export function createActions(ctx) {
             return;
         }
         // Single unified stream with TypedEvents (both Chat and ChatMessage events)
-        const { url, headers, credentials } = api.getChatStreamConfig(client, id);
         const manager = new StreamableManager({
-            url,
-            headers,
-            credentials,
+            request: api.chatStreamRequest(client, id),
             onError: (error) => {
                 console.warn('[AgentSDK] Stream error:', error);
                 callbacks.onError?.(error);

package/dist/agent/api.d.ts

@@ -9,6 +9,7 @@
  */
 import type { AlwaysAllowOptionsDTO, AlwaysAllowResultDTO, ChatAgentDTO, ChatDTO, ChatMessageDTO, ChatSettingsDTO, ChatSettingsRequest, InterruptDTO, ToolExplanationDTO } from '../types';
 import type { AgentOptions, AgentClient, AgentInfo, FileRef } from './types';
+import type { StreamRequest } from '../http/streamable';
 export interface SendResult {
     chatId: string;
     userMessage: ChatMessageDTO;
@@ -69,8 +70,4 @@ export declare function updateChatSettings(client: AgentClient, chatId: string,
 export declare function resolveInterrupt(client: AgentClient, interruptId: string, decision: 'allow' | 'deny'): Promise<InterruptDTO>;
 export declare function listRunInterrupts(client: AgentClient, runId: string): Promise<InterruptDTO[]>;
 export declare function uploadFile(client: AgentClient, file: globalThis.File): Promise<FileRef>;
-export declare function getChatStreamConfig(client: AgentClient, chatId: string): {
-    url: string;
-    headers: Record<string, string>;
-    credentials: RequestCredentials;
-};
+export declare function chatStreamRequest(client: AgentClient, chatId: string): StreamRequest;

package/dist/agent/api.js

@@ -203,6 +203,6 @@ export async function listRunInterrupts(client, runId) {
 export async function uploadFile(client, file) {
     return client.files.upload(file);
 }
-export function getChatStreamConfig(client, chatId) {
-    return client.http.getStreamableConfig(`/chats/${chatId}/stream`);
+export function chatStreamRequest(client, chatId) {
+    return (init) => client.http.fetch(`/chats/${chatId}/stream`, init);
 }

package/dist/agent/types.d.ts

@@ -19,7 +19,7 @@ export interface AlwaysAllowChoice {
  */
 export interface AgentClient {
     /** HTTP client for API requests */
-    http: Pick<HttpClient, 'request' | 'getStreamableConfig' | 'getStreamDefault' | 'getPollIntervalMs'>;
+    http: Pick<HttpClient, 'request' | 'fetch' | 'getStreamDefault' | 'getPollIntervalMs'>;
     /** Files API for uploads */
     files: {
         upload: (data: string | Blob | globalThis.File) => Promise<FileRef>;

package/dist/api/agents.js

@@ -209,13 +209,11 @@ export class Agent {
     streamUntilIdle(options, gate) {
         if (!this.chatId)
             return Promise.resolve();
-        const { url, headers, credentials } = this.http.getStreamableConfig(`/chats/${this.chatId}/stream`);
+        const endpoint = `/chats/${this.chatId}/stream`;
         return new Promise((resolve) => {
             this.stream?.stop();
             this.stream = new StreamableManager({
-                url,
-                headers,
-                credentials,
+                request: (init) => this.http.fetch(endpoint, init),
             });
             // Last chat/run observation was idle but the gate wasn't settled yet;
             // a terminal message for this turn can settle it.

package/dist/api/tasks.js

@@ -110,7 +110,6 @@ export class TasksAPI {
         const { onUpdate, onPartialUpdate, onDelta } = options;
         // Accumulate state across partial updates to preserve fields like session_id
         let accumulatedTask = { ...task };
-        const { url, headers, credentials } = this.http.getStreamableConfig(`/tasks/${task.id}/stream`);
         let streamManager;
         const done = new Promise((resolve, reject) => {
             const settle = (data, stripped) => {
@@ -128,9 +127,7 @@ export class TasksAPI {
                 }
             };
             streamManager = new StreamableManager({
-                url,
-                headers,
-                credentials,
+                request: (init) => this.http.fetch(`/tasks/${task.id}/stream`, init),
                 onDelta,
                 onData: (data) => {
                     // Merge new data, preserving existing fields if not in update

package/dist/http/client.d.ts

@@ -1,10 +1,26 @@
 import type { Response } from './response';
 import { EventSource } from 'eventsource';
+/** What a failed request was sent with, for an error handler that acts on it. */
+export interface FailedRequest {
+    /**
+     * The bearer token the request carried, or undefined when it carried none
+     * (proxy mode, or no apiKey and getToken returned nothing). A handler that
+     * refreshes credentials compares it with the token in hand: when they
+     * differ, the credentials were already replaced and a retry is enough.
+     */
+    token: string | undefined;
+}
 /**
  * Error handler that can intercept errors and optionally retry the request.
  * Return a promise to retry with a new result, or throw/rethrow to propagate the error.
+ * `retry` sends the request again with the token of that moment and does not
+ * come back through the handler. `request` describes the attempt that failed.
  */
-export type ErrorHandler = (error: unknown, retry: () => Promise<unknown>) => Promise<unknown>;
+export type ErrorHandler = (error: unknown, retry: () => Promise<unknown>, request: FailedRequest) => Promise<unknown>;
+/** Options of HttpClient.fetch: a fetch init whose credentials mode is the client's. */
+export type HttpFetchInit = Omit<RequestInit, 'headers' | 'credentials'> & {
+    headers?: Record<string, string>;
+};
 export type MessageHandler = (messages: import('../types').ResponseMessage[]) => void;
 export interface HttpClientConfig {
     /** Your inference.sh API key (required unless using proxyUrl) */
@@ -16,8 +32,11 @@ export interface HttpClientConfig {
      * When set, requests are routed through your proxy server to protect API keys.
      */
     proxyUrl?: string;
-    /** Dynamic token getter (alternative to apiKey) */
-    getToken?: () => string | null | undefined;
+    /**
+     * Dynamic token getter (alternative to apiKey), asked before every request.
+     * It may be async: the request waits for the token.
+     */
+    getToken?: () => string | null | undefined | Promise<string | null | undefined>;
     /** Dynamic headers */
     headers?: Record<string, string | (() => string | undefined)>;
     /** Request credentials mode */
@@ -71,15 +90,53 @@ export declare class HttpClient {
     isProxyMode(): boolean;
     /** Resolve dynamic headers */
     private resolveHeaders;
-    /** Get authorization token */
-    private getAuthToken;
+    /** The bearer token a request sent now carries; none through a proxy, which adds its own. */
+    private bearerToken;
+    /** The configured headers plus what identifies the request: its bearer, or through a proxy its target. */
+    private requestHeaders;
+    /**
+     * 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.
+     */
+    private streamUrl;
     /**
      * Make an HTTP request to the API
      */
-    request<T, P extends object = Record<string, unknown>>(method: 'get' | 'post' | 'put' | 'delete', endpoint: string, options?: {
+    request<T, P extends object = Record<string, unknown>>(method: 'get' | 'post' | 'put' | 'delete', endpoint: string, { handleErrors, ...options }?: {
         params?: P;
         data?: unknown;
+        /**
+         * `false` when the caller handles this request's failure itself: the
+         * client's error handler (onError) is not consulted, so there is no
+         * prompt, no redirect and no retry, and the error is thrown as it is.
+         */
+        handleErrors?: boolean;
     }): Promise<Response<T>>;
+    /**
+     * 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.
+     */
+    fetch(endpoint: string, init?: HttpFetchInit): Promise<globalThis.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.
+     */
+    private fetchHandled;
+    /** The error a refused response stands for, read from its body. */
+    private readError;
+    /** HTTP errors → RFC 9457 problem+json */
+    private responseError;
     /**
      * Execute the actual HTTP request (internal)
      */
@@ -87,6 +144,10 @@ export declare 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: string): {
         url: string;
@@ -100,7 +161,7 @@ export declare class HttpClient {
     private extractErrorDetail;
     /**
      * Create an EventSource for SSE streaming
-     * @deprecated Use getStreamableConfig() with StreamableManager instead
+     * @deprecated Use StreamableManager with a StreamRequest instead
      */
     createEventSource(endpoint: string): Promise<EventSource | null>;
 }

package/dist/http/client.js

@@ -54,32 +54,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 +199,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 +221,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 +240,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 +269,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/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>;