@inferencesh/sdk 0.22.0 → 0.23.0

package/dist/api/credentials.d.ts

@@ -1,6 +1,6 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import { CheckRequirementsRequest, CheckRequirementsResponse, CredentialDTO, CredentialConfigDTO, CredentialConnectRequest, CredentialConnectResponse, CursorListRequest, CursorListResponse } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import { CheckRequirementsRequest, CheckRequirementsResponse, CredentialDTO, CredentialConfigDTO, CredentialConnectRequest, CredentialConnectResponse, CursorListRequest, CursorListResponse } from '../types.js';
 /**
  * Credentials API: the accounts and keys a team has connected to external services.
  */

package/dist/api/engines.d.ts

@@ -1,7 +1,7 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import type { EngineUpdateBody } from './write-bodies';
-import { EngineDTO as Engine, CursorListRequest, CursorListResponse } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import type { EngineUpdateBody } from './write-bodies.js';
+import { EngineDTO as Engine, CursorListRequest, CursorListResponse } from '../types.js';
 /**
  * Engines API
  */

package/dist/api/files.d.ts

@@ -1,6 +1,6 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import { FileDTO as File, CursorListRequest, CursorListResponse } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import { FileDTO as File, CursorListRequest, CursorListResponse } from '../types.js';
 export interface UploadFileOptions {
     filename?: string;
     contentType?: string;

package/dist/api/flow-runs.d.ts

@@ -1,6 +1,6 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import { FlowRunDTO as FlowRun, CursorListRequest, CursorListResponse } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import { FlowRunDTO as FlowRun, CursorListRequest, CursorListResponse } from '../types.js';
 /**
  * Flow Runs API
  */

package/dist/api/flows.d.ts

@@ -1,7 +1,7 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import type { FlowPatchBody, FlowUpdateBody, FlowViewportBody } from './write-bodies';
-import { FlowDTO as Flow, FlowVersionDTO, AppDTO as App, CursorListRequest, CursorListResponse } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import type { FlowPatchBody, FlowUpdateBody, FlowViewportBody } from './write-bodies.js';
+import { FlowDTO as Flow, FlowVersionDTO, AppDTO as App, CursorListRequest, CursorListResponse } from '../types.js';
 /**
  * Flows API
  */

package/dist/api/index.d.ts

@@ -1,4 +1,4 @@
-export { TasksAPI, createTasksAPI, type RunOptions } from './tasks';
-export { FilesAPI, createFilesAPI, type UploadFileOptions } from './files';
-export { AgentsAPI, createAgentsAPI, Agent, type AgentOptions, type SendMessageOptions, type AgentRunOptions } from './agents';
-export { SessionsAPI, createSessionsAPI } from './sessions';
+export { TasksAPI, createTasksAPI, type RunOptions } from './tasks.js';
+export { FilesAPI, createFilesAPI, type UploadFileOptions } from './files.js';
+export { AgentsAPI, createAgentsAPI, Agent, type AgentOptions, type SendMessageOptions, type AgentRunOptions } from './agents.js';
+export { SessionsAPI, createSessionsAPI } from './sessions.js';

package/dist/api/index.js

@@ -1,4 +1,4 @@
-export { TasksAPI, createTasksAPI } from './tasks';
-export { FilesAPI, createFilesAPI } from './files';
-export { AgentsAPI, createAgentsAPI, Agent } from './agents';
-export { SessionsAPI, createSessionsAPI } from './sessions';
+export { TasksAPI, createTasksAPI } from './tasks.js';
+export { FilesAPI, createFilesAPI } from './files.js';
+export { AgentsAPI, createAgentsAPI, Agent } from './agents.js';
+export { SessionsAPI, createSessionsAPI } from './sessions.js';

package/dist/api/knowledge.d.ts

@@ -1,7 +1,7 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import type { KnowledgeUpdateBody } from './write-bodies';
-import { KnowledgeDTO, KnowledgeVersionDTO, KnowledgeCreateRequest, SkillDTO, SkillVersionDTO, CursorListRequest, CursorListResponse, PublicSkillStoreDTO } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import type { KnowledgeUpdateBody } from './write-bodies.js';
+import { KnowledgeDTO, KnowledgeVersionDTO, KnowledgeCreateRequest, SkillDTO, SkillVersionDTO, CursorListRequest, CursorListResponse, PublicSkillStoreDTO } from '../types.js';
 /**
  * Knowledge API
  */

package/dist/api/mcp-servers.d.ts

@@ -1,7 +1,7 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import type { MCPServerUpdateBody } from './write-bodies';
-import { MCPServerDTO, CursorListRequest, CursorListResponse } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import type { MCPServerUpdateBody } from './write-bodies.js';
+import { MCPServerDTO, CursorListRequest, CursorListResponse } from '../types.js';
 /**
  * MCP Servers API
  */

package/dist/api/projects.d.ts

@@ -1,7 +1,7 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import type { ProjectWriteBody } from './write-bodies';
-import { ProjectDTO, CursorListRequest, CursorListResponse } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import type { ProjectWriteBody } from './write-bodies.js';
+import { ProjectDTO, CursorListRequest, CursorListResponse } from '../types.js';
 /**
  * Projects API
  */

package/dist/api/search.d.ts

@@ -1,6 +1,6 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import { SuggestRequest, SuggestResponse } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import { SuggestRequest, SuggestResponse } from '../types.js';
 /**
  * Search API
  */

package/dist/api/secrets.d.ts

@@ -1,6 +1,6 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import { SecretDTO, SecretCreateRequest, SecretUpdateRequest, CursorListRequest, CursorListResponse } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import { SecretDTO, SecretCreateRequest, SecretUpdateRequest, CursorListRequest, CursorListResponse } from '../types.js';
 /**
  * Secrets API
  */

package/dist/api/sessions.d.ts

@@ -1,9 +1,9 @@
 /**
  * Sessions API - namespaced session operations.
  */
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import { AppSessionDTO } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import { AppSessionDTO } from '../types.js';
 /**
  * Sessions API for managing stateful worker leases.
  *

package/dist/api/sockets.d.ts

@@ -1,9 +1,9 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import { LiveSession, type LiveHandlers, type WebSocketConstructor } from '../live/session';
-import type { JsonSchema } from '../live/schema';
-import { CursorListRequest, CursorListResponse, SocketAccess, SocketDTO, TaskDTO as Task } from '../types';
-import type { TasksAPI } from './tasks';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import { LiveSession, type LiveHandlers, type WebSocketConstructor } from '../live/session.js';
+import type { JsonSchema } from '../live/schema.js';
+import { CursorListRequest, CursorListResponse, SocketAccess, SocketDTO, TaskDTO as Task } from '../types.js';
+import type { TasksAPI } from './tasks.js';
 /** What identifies the socket to open: the run response (which carries the access), a task, or a task id. */
 export type SocketTarget = (Pick<Task, 'id' | 'status'> & {
     socket?: SocketAccess;

package/dist/api/sockets.js

@@ -1,5 +1,5 @@
-import { LiveSession } from '../live/session';
-import { OpEqual } from '../types';
+import { LiveSession } from '../live/session.js';
+import { OpEqual } from '../types.js';
 /**
  * Sockets API: the duplex connection of a stream task.
  *

package/dist/api/tasks.d.ts

@@ -1,6 +1,6 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import { TaskDTO as Task, TaskLogsDTO, TaskTimingsDTO, ApiAppRunRequest, TaskResultDTO, CursorListRequest, CursorListResponse, TaskFileDTO, DeleteTaskFilesResponse } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import { TaskDTO as Task, TaskLogsDTO, TaskTimingsDTO, ApiAppRunRequest, TaskResultDTO, CursorListRequest, CursorListResponse, TaskFileDTO, DeleteTaskFilesResponse } from '../types.js';
 /** How to follow a task while it runs; see TasksAPI.watch. */
 export interface WatchOptions {
     /** Callback for real-time status updates */

package/dist/api/tasks.js

@@ -1,7 +1,7 @@
-import { streamUntilTerminal } from '../http/stream-until-terminal';
-import { PollManager } from '../http/poll';
-import { TaskStatusCompleted, TaskStatusFailed, TaskStatusCancelled, } from '../types';
-import { parseStatus } from '../utils';
+import { streamUntilTerminal } from '../http/stream-until-terminal.js';
+import { PollManager } from '../http/poll.js';
+import { TaskStatusCompleted, TaskStatusFailed, TaskStatusCancelled, } from '../types.js';
+import { parseStatus } from '../utils.js';
 //TODO: This is ugly...
 function stripTask(task) {
     return {

package/dist/api/teams.d.ts

@@ -1,7 +1,7 @@
-import { HttpClient } from '../http/client';
-import type { Response } from '../http/response';
-import type { TeamUpdateBody } from './write-bodies';
-import { MeResponse, TeamDTO, TeamMemberDTO, TeamInviteDTO, TeamCreateRequest, TeamMemberAddRequest, TeamInviteCreateRequest, AvailabilityResponse } from '../types';
+import { HttpClient } from '../http/client.js';
+import type { Response } from '../http/response.js';
+import type { TeamUpdateBody } from './write-bodies.js';
+import { MeResponse, TeamDTO, TeamMemberDTO, TeamInviteDTO, TeamCreateRequest, TeamMemberAddRequest, TeamInviteCreateRequest, AvailabilityResponse } from '../types.js';
 /**
  * Teams API
  */

package/dist/api/write-bodies.d.ts

@@ -12,7 +12,7 @@
  * chats, engines and teams send PATCH; apps.patch and flows.patch are the
  * partial siblings of the POST updates that also edit a version.
  */
-import type { AgentConfigInput, AgentImages, AppDTO, ChatDTO, EngineDTO, FlowDTO, FlowVersionDTO, KnowledgeDTO, MCPServerAuthType, ProjectDTO, TeamDTO, Visibility } from '../types';
+import type { AgentConfigInput, AgentImages, AppDTO, ChatDTO, EngineDTO, FlowDTO, FlowVersionDTO, KnowledgeDTO, MCPServerAuthType, ProjectDTO, TeamDTO, Visibility } from '../types.js';
 /**
  * POST /agents/{id}. Visibility and images, and a new version when
  * `version` is set. Name, title, harness, placement: set at creation.

package/dist/delta.d.ts

@@ -1,4 +1,4 @@
-export type { DeltaEvent } from './types';
+export type { DeltaEvent } from './types.js';
 export type FieldTags = Record<string, {
     merge: string;
 }>;

package/dist/delta.js

@@ -1,4 +1,4 @@
-import { LLMDelta_fieldTags, ToolCallDelta_fieldTags, ToolCallFunctionDelta_fieldTags, MergeStrategyConcat, MergeStrategyIndexed, MergeStrategyNested, MergeStrategyReplace, } from './types';
+import { LLMDelta_fieldTags, ToolCallDelta_fieldTags, ToolCallFunctionDelta_fieldTags, MergeStrategyConcat, MergeStrategyIndexed, MergeStrategyNested, MergeStrategyReplace, } from './types.js';
 function mergeField(current, incoming, strategy, childTags, registry) {
     if (incoming == null)
         return current;

package/dist/hook-builder.d.ts

@@ -1,7 +1,7 @@
 /**
  * Hook Builder - Fluent API for defining lifecycle hooks
  */
-import { LifecycleHookConfig, HookEvent, BuiltinHook } from './types';
+import { LifecycleHookConfig, HookEvent, BuiltinHook } from './types.js';
 export declare class LifecycleHookBuilder {
     private event;
     private handlerType;

package/dist/hook-builder.js

@@ -1,7 +1,7 @@
 /**
  * Hook Builder - Fluent API for defining lifecycle hooks
  */
-import { HookHandlerWebhook, HookHandlerTask, HookHandlerBuiltin, BuiltinHookBeltSuggest, BuiltinHookBeltExtract, HookEventTurnStart, HookEventAgentComplete, HookEventPreCompact, } from './types';
+import { HookHandlerWebhook, HookHandlerTask, HookHandlerBuiltin, BuiltinHookBeltSuggest, BuiltinHookBeltExtract, HookEventTurnStart, HookEventAgentComplete, HookEventPreCompact, } from './types.js';
 // =============================================================================
 // Hook Builder
 // =============================================================================

package/dist/http/client.d.ts

@@ -1,4 +1,4 @@
-import type { Response } from './response';
+import type { Response } from './response.js';
 import { EventSource } from 'eventsource';
 /** What a failed request was sent with, for an error handler that acts on it. */
 export interface FailedRequest {
@@ -21,7 +21,7 @@ export type ErrorHandler = (error: unknown, retry: () => Promise<unknown>, reque
 export type HttpFetchInit = Omit<RequestInit, 'headers' | 'credentials'> & {
     headers?: Record<string, string>;
 };
-export type MessageHandler = (messages: import('../types').ResponseMessage[]) => void;
+export type MessageHandler = (messages: import('../types.js').ResponseMessage[]) => void;
 export interface HttpClientConfig {
     /** Your inference.sh API key (required unless using proxyUrl) */
     apiKey?: string;

package/dist/http/client.js

@@ -1,6 +1,6 @@
-import { InferenceError, RequirementsNotMetException } from './errors';
+import { InferenceError, RequirementsNotMetException } from './errors.js';
 import { EventSource } from 'eventsource';
-import { SDK_VERSION } from '../version';
+import { SDK_VERSION } from '../version.js';
 /**
  * Low-level HTTP client for inference.sh API
  *

package/dist/http/errors.d.ts

@@ -4,7 +4,7 @@
  * Note: types.ts contains interfaces (APIError, RequirementsNotMetError) that describe
  * the API response data shapes. These classes are throwable Error subclasses for SDK use.
  */
-import type { RequirementError } from '../types';
+import type { RequirementError } from '../types.js';
 /**
  * General HTTP/API error thrown by the SDK.
  *

package/dist/http/index.d.ts

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

package/dist/http/index.js

@@ -1,4 +1,4 @@
-export { HttpClient, createHttpClient } from './client';
-export { StreamManager } from './stream';
-export { streamable, streamableRaw, StreamableManager } from './streamable';
-export { InferenceError, RequirementsNotMetException } from './errors';
+export { HttpClient, createHttpClient } from './client.js';
+export { StreamManager } from './stream.js';
+export { streamable, streamableRaw, StreamableManager } from './streamable.js';
+export { InferenceError, RequirementsNotMetException } from './errors.js';

package/dist/http/response.d.ts

@@ -1,4 +1,4 @@
-import type { ResponseMessage } from '../types';
+import type { ResponseMessage } from '../types.js';
 /**
  * Response wraps the V3 API envelope — every API call returns this.
  * Access .data for the DTO and .messages for any warnings the server surfaced.

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

@@ -2,15 +2,21 @@
  * 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.
+ * The stream reconnects after a network failure or a silent connection
+ * (StreamableManager `reconnect`, on by default here). The API does not
+ * replay what a dropped stream missed, so every reconnect fetches the
+ * resource (`resync`, default `reconcile`) before reading on; a resource
+ * that finished meanwhile settles the wait.
+ *
+ * A stream can also 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. The wait rejects
+ * with the stream's error once it stops retrying.
  */
-import { type StreamableManagerOptions, type StreamRequest } from './streamable';
+import { type StreamableManagerOptions, type StreamReconnectOptions, type StreamRequest } from './streamable.js';
 /** Settles a stream-until-terminal wait. Calls after the first are ignored. */
 export interface TerminalSettler<R> {
     resolve(value: R): void;
@@ -28,6 +34,14 @@ export type StreamUntilTerminalSpec<T> = Pick<StreamableManagerOptions<T>, 'body
      * rejects the wait with `closedMessage`.
      */
     reconcile: () => Promise<void>;
+    /**
+     * Called after the stream reconnected, before it is read again: fetch the
+     * resource and report it, settling if it is terminal (default `reconcile`).
+     * A rejection counts as a failed reconnect attempt.
+     */
+    resync?: () => Promise<void>;
+    /** How the stream reconnects (default true: StreamReconnectOptions defaults); false fails the wait on the first error. */
+    reconnect?: boolean | StreamReconnectOptions;
     /** Rejection message when the stream closed and the resource is still not terminal. */
     closedMessage: string;
     /**

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

@@ -2,15 +2,21 @@
  * 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.
+ * The stream reconnects after a network failure or a silent connection
+ * (StreamableManager `reconnect`, on by default here). The API does not
+ * replay what a dropped stream missed, so every reconnect fetches the
+ * resource (`resync`, default `reconcile`) before reading on; a resource
+ * that finished meanwhile settles the wait.
+ *
+ * A stream can also 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. The wait rejects
+ * with the stream's error once it stops retrying.
  */
-import { StreamableManager } from './streamable';
+import { StreamableManager } from './streamable.js';
 /**
  * `build` receives the settler and returns the stream spec; its handlers call
  * `settle.resolve`/`settle.reject` once the resource is terminal. Settling
@@ -39,10 +45,12 @@ export function streamUntilTerminal(build) {
                 reject(error);
             },
         };
-        const { events, reconcile, closedMessage, onStopped, keepOpen, ...managerOptions } = build(settle);
+        const { events, reconcile, resync = reconcile, reconnect = true, closedMessage, onStopped, keepOpen, ...managerOptions } = build(settle);
         let streamError = null;
         manager = new StreamableManager({
             ...managerOptions,
+            reconnect,
+            onReconnect: () => resync(),
             onError: (error) => {
                 streamError = error;
             },

package/dist/http/streamable.d.ts

@@ -46,6 +46,28 @@ export interface StreamableMessage<T = unknown> {
  * `source` is the URL to fetch, or a StreamRequest that sends the request.
  */
 export declare function streamable<T = unknown>(source: string | StreamRequest, options?: StreamableOptions): AsyncGenerator<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>(source: string | StreamRequest, options?: StreamableOptions): AsyncGenerator<StreamableMessage<T> | T>;
+/** How a StreamableManager reconnects after its stream fails. */
+export interface StreamReconnectOptions {
+    /**
+     * Failed connection attempts in a row before the manager gives up and calls
+     * `onError` (default 10). Any line received, heartbeats included, resets the count.
+     */
+    maxAttempts?: number;
+    /** Delay before the first retry in ms (default 1000). It doubles per attempt, with jitter. */
+    baseDelayMs?: number;
+    /** Longest delay between retries in ms (default 30000). */
+    maxDelayMs?: number;
+    /**
+     * Reconnect when nothing, not even a heartbeat, arrives for this many ms
+     * (default 30000; the API sends a heartbeat every 10s). 0 turns it off.
+     */
+    idleTimeoutMs?: number;
+}
 /**
  * StreamableManager provides a callback-based API similar to StreamManager
  * but uses fetch + ReadableStream instead of EventSource.
@@ -69,19 +91,46 @@ export type StreamableManagerOptions<T> = StreamableSource & {
     onData?: (data: T) => void;
     /** Called for partial updates with fields list */
     onPartialData?: (data: T, fields: string[]) => void;
-    /** Called on error */
+    /**
+     * Called when the stream fails. With `reconnect`, only once the manager
+     * gives up: a refusal no retry would change (4xx other than 408/429), or
+     * `maxAttempts` failures in a row.
+     */
     onError?: (error: Error) => void;
     /** Called when stream starts */
     onStart?: () => void;
-    /** Called when stream ends */
+    /**
+     * Called once when the manager is done: the stream ended cleanly, stop()
+     * was called, or it failed and will not retry.
+     */
     onEnd?: () => void;
     /** Called for delta events (streaming token deltas) */
     onDelta?: (delta: Record<string, any>, seq: number) => void;
+    /**
+     * Reconnect after the stream fails or goes silent (default false: a failure
+     * ends the stream). `true` uses the StreamReconnectOptions defaults. A clean
+     * end of the stream is not retried.
+     */
+    reconnect?: boolean | StreamReconnectOptions;
+    /** With `reconnect`: the stream failed and the manager retries after `delayMs`. */
+    onRetry?: (error: Error, attempt: number, delayMs: number) => void;
+    /**
+     * With `reconnect`: a retry got a new connection. Events sent while the
+     * stream was down are lost, so this is where the caller fetches the current
+     * state. The manager reads the new stream only after the returned promise
+     * settles, so what it reads is newer than what the caller fetched; a
+     * rejection counts as a failed attempt.
+     */
+    onReconnect?: (attempt: number) => void | Promise<void>;
 };
 export declare class StreamableManager<T> {
     private options;
     private abortController;
     private isRunning;
+    /** Bumped by start() and stop(), so a stopped run never acts again. */
+    private runId;
+    /** Ends a pending retry wait early (stop, online, tab visible). */
+    private wakeRetry;
     private eventListeners;
     constructor(options: StreamableManagerOptions<T>);
     /**
@@ -90,10 +139,17 @@ export declare class StreamableManager<T> {
      */
     addEventListener<E = unknown>(eventName: string, callback: (data: E, fields?: string[]) => void): () => void;
     start(): Promise<void>;
+    /**
+     * One connection: open the stream and dispatch its messages until it ends.
+     * Resolves on a clean end, throws when the request or the read fails.
+     */
+    private connect;
+    /** Route one message to onDelta, a typed event listener, onPartialData or onData. */
+    private dispatch;
+    /**
+     * Wait `delayMs` before the next attempt. In a browser, coming back online
+     * or the tab becoming visible retries at once; stop() ends the wait.
+     */
+    private waitToRetry;
     stop(): void;
 }
-/**
- * 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>(source: string | StreamRequest, options?: StreamableOptions): AsyncGenerator<StreamableMessage<T> | T>;