@inferencesh/sdk 0.22.0 → 0.23.0

package/dist/http/streamable.js

@@ -28,19 +28,46 @@ async function openStream(source, { headers = {}, body, method = body ? 'POST' :
     }
     return res.body;
 }
+/** The error a stream read sees when its signal aborts. */
+function abortError() {
+    const error = new Error('The operation was aborted');
+    error.name = 'AbortError';
+    return error;
+}
 /**
- * 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.
+ * Resolves with `promise`, or rejects with an AbortError once `signal`
+ * aborts. A request or body that ignores the signal cannot hold the caller.
  */
-export async function* streamable(source, options = {}) {
-    const { skipHeartbeats = true } = options;
-    const reader = (await openStream(source, options)).getReader();
+function untilAborted(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(abortError());
+    return new Promise((resolve, reject) => {
+        const onAbort = () => reject(abortError());
+        signal.addEventListener('abort', onAbort, { once: true });
+        promise.then(resolve, reject).finally(() => signal.removeEventListener('abort', onAbort));
+    });
+}
+/** Run a cleanup that may throw or reject; its failure changes nothing. */
+function quietly(cleanup) {
+    try {
+        cleanup()?.catch(() => { });
+    }
+    catch {
+        // Already closed.
+    }
+}
+/** Every parsed NDJSON line of `body`, heartbeats included. Aborting `signal` ends the read with an AbortError. */
+async function* readLines(body, signal) {
+    const reader = body.getReader();
     const decoder = new TextDecoder();
     let buffer = '';
+    const cancel = () => quietly(() => reader.cancel?.());
+    signal?.addEventListener('abort', cancel, { once: true });
     try {
         while (true) {
-            const { done, value } = await reader.read();
+            const { done, value } = await untilAborted(reader.read(), signal);
             if (done)
                 break;
             buffer += decoder.decode(value, { stream: true });
@@ -49,42 +76,91 @@ export async function* streamable(source, options = {}) {
             for (const line of lines) {
                 if (!line.trim())
                     continue;
-                const parsed = JSON.parse(line);
-                // Skip heartbeats
-                if (skipHeartbeats && parsed.type === 'heartbeat') {
-                    continue;
-                }
-                // If it's a wrapped message with event/data/fields, yield the data
-                // Otherwise yield the entire parsed object
-                if ('data' in parsed && parsed.data !== undefined) {
-                    yield parsed.data;
-                }
-                else {
-                    yield parsed;
-                }
+                yield JSON.parse(line);
             }
         }
         // Handle remaining buffer
         if (buffer.trim()) {
-            const parsed = JSON.parse(buffer);
-            if (!(skipHeartbeats && parsed.type === 'heartbeat')) {
-                if ('data' in parsed && parsed.data !== undefined) {
-                    yield parsed.data;
-                }
-                else {
-                    yield parsed;
-                }
-            }
+            yield JSON.parse(buffer);
         }
     }
     finally {
-        reader.releaseLock();
+        signal?.removeEventListener('abort', cancel);
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // A read still pending after an abort can make releaseLock throw.
+        }
+    }
+}
+const isHeartbeat = (parsed) => typeof parsed === 'object' && parsed !== null && parsed.type === 'heartbeat';
+/**
+ * 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 async function* streamable(source, options = {}) {
+    for await (const parsed of streamableRaw(source, options)) {
+        const message = parsed;
+        // If it's a wrapped message with event/data/fields, yield the data
+        // Otherwise yield the entire parsed object
+        if (typeof message === 'object' && message !== null && 'data' in message && message.data !== undefined) {
+            yield message.data;
+        }
+        else {
+            yield parsed;
+        }
     }
 }
+/**
+ * Raw streamable that yields the full message including wrapper.
+ * Use this when you need access to event type or fields.
+ */
+export async function* streamableRaw(source, options = {}) {
+    const { skipHeartbeats = true } = options;
+    for await (const parsed of readLines(await openStream(source, options), options.signal)) {
+        if (skipHeartbeats && isHeartbeat(parsed))
+            continue;
+        yield parsed;
+    }
+}
+const RECONNECT_DEFAULTS = {
+    maxAttempts: 10,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    idleTimeoutMs: 30000,
+};
+/** The HTTP status an error carries, if any. */
+function errorStatus(error) {
+    const { statusCode, status } = error;
+    if (typeof statusCode === 'number')
+        return statusCode;
+    if (typeof status === 'number')
+        return status;
+    const match = /^HTTP (\d{3})\b/.exec(error.message);
+    return match ? Number(match[1]) : undefined;
+}
+/** A refusal that a retry would get again: any 4xx except 408 (timeout) and 429 (rate limit). */
+function isRetryable(error) {
+    const status = errorStatus(error);
+    if (status === undefined)
+        return true;
+    return !(status >= 400 && status < 500 && status !== 408 && status !== 429);
+}
+/** Exponential backoff for retry `attempt` (1-based), jittered to [50%, 100%] of the step. */
+function backoffDelay(policy, attempt) {
+    const step = Math.min(policy.maxDelayMs, policy.baseDelayMs * 2 ** (attempt - 1));
+    return Math.round(step / 2 + Math.random() * (step / 2));
+}
 export class StreamableManager {
     constructor(options) {
         this.abortController = null;
         this.isRunning = false;
+        /** Bumped by start() and stop(), so a stopped run never acts again. */
+        this.runId = 0;
+        /** Ends a pending retry wait early (stop, online, tab visible). */
+        this.wakeRetry = null;
         this.eventListeners = new Map();
         this.options = options;
     }
@@ -111,116 +187,198 @@ export class StreamableManager {
         if (this.isRunning)
             return;
         this.isRunning = true;
-        this.abortController = new AbortController();
+        const run = ++this.runId;
+        const active = () => this.runId === run;
+        const { reconnect } = this.options;
+        const policy = reconnect
+            ? { ...RECONNECT_DEFAULTS, ...(reconnect === true ? {} : reconnect) }
+            : null;
+        // Failed attempts in a row; any line received resets it.
+        let failures = 0;
+        let attempts = 0;
         try {
             this.options.onStart?.();
-            const { options } = this;
-            const stream = 'request' in options
-                ? streamableRaw(options.request, { body: options.body, signal: this.abortController.signal })
-                : streamableRaw(options.url, {
-                    headers: options.headers,
-                    body: options.body,
-                    signal: this.abortController.signal,
-                    credentials: options.credentials,
-                });
-            for await (const message of stream) {
-                if (!this.isRunning)
-                    break;
-                const wrapper = message;
-                // Handle delta events
-                if (wrapper.event === 'delta' && this.options.onDelta) {
-                    const payload = wrapper.data;
-                    if (payload && payload.delta) {
-                        this.options.onDelta(payload.delta, payload.seq);
-                    }
-                    continue;
+            while (active()) {
+                const retry = attempts++ > 0 ? failures : 0;
+                const idle = { timedOut: false };
+                let error = null;
+                try {
+                    await this.connect(active, policy?.idleTimeoutMs ?? 0, idle, retry, () => {
+                        failures = 0;
+                    });
                 }
-                // Handle typed events ({"event": "...", "data": ...})
-                if (wrapper.event && this.eventListeners.has(wrapper.event)) {
-                    const listeners = this.eventListeners.get(wrapper.event);
-                    const eventData = wrapper.data !== undefined ? wrapper.data : message;
-                    const fields = wrapper.fields;
-                    listeners.forEach(callback => callback(eventData, fields));
-                    continue;
+                catch (err) {
+                    error = err instanceof Error ? err : new Error(String(err));
                 }
-                // Check if it's a partial update
-                if (typeof message === 'object' &&
-                    message !== null &&
-                    'data' in message &&
-                    'fields' in message &&
-                    Array.isArray(wrapper.fields)) {
-                    if (this.options.onPartialData && wrapper.data !== undefined) {
-                        this.options.onPartialData(wrapper.data, wrapper.fields);
-                    }
-                    else if (wrapper.data !== undefined) {
-                        this.options.onData?.(wrapper.data);
-                    }
+                if (!active())
+                    break;
+                if (idle.timedOut) {
+                    error = new Error(`Stream received nothing for ${policy.idleTimeoutMs}ms`);
                 }
-                else if (wrapper.data !== undefined) {
-                    // Has data wrapper but no fields - unwrap
-                    this.options.onData?.(wrapper.data);
+                if (!error)
+                    break; // ended cleanly
+                if (!policy) {
+                    if (error.name !== 'AbortError')
+                        this.options.onError?.(error);
+                    break;
                 }
-                else {
-                    this.options.onData?.(message);
+                if (!isRetryable(error) || failures >= policy.maxAttempts) {
+                    this.options.onError?.(error);
+                    break;
                 }
+                failures++;
+                const delay = backoffDelay(policy, failures);
+                this.options.onRetry?.(error, failures, delay);
+                await this.waitToRetry(delay);
             }
         }
         catch (err) {
-            if (err instanceof Error && err.name === 'AbortError') {
-                // Intentional stop, not an error
-            }
-            else {
+            // A callback threw outside a connection.
+            if (active())
                 this.options.onError?.(err instanceof Error ? err : new Error(String(err)));
-            }
         }
         finally {
-            this.isRunning = false;
+            if (active()) {
+                this.isRunning = false;
+                this.abortController = null;
+            }
             this.options.onEnd?.();
         }
     }
-    stop() {
-        this.isRunning = false;
-        this.abortController?.abort();
-        this.abortController = null;
-    }
-}
-/**
- * Raw streamable that yields the full message including wrapper.
- * Use this when you need access to event type or fields.
- */
-export async function* streamableRaw(source, options = {}) {
-    const { skipHeartbeats = true } = options;
-    const reader = (await openStream(source, options)).getReader();
-    const decoder = new TextDecoder();
-    let buffer = '';
-    try {
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done)
-                break;
-            buffer += decoder.decode(value, { stream: true });
-            const lines = buffer.split('\n');
-            buffer = lines.pop();
-            for (const line of lines) {
-                if (!line.trim())
-                    continue;
-                const parsed = JSON.parse(line);
-                // Skip heartbeats
-                if (skipHeartbeats && parsed.type === 'heartbeat') {
-                    continue;
+    /**
+     * 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.
+     */
+    async connect(active, idleTimeoutMs, idle, retry, onActivity) {
+        const controller = new AbortController();
+        this.abortController = controller;
+        const { signal } = controller;
+        let watchdog;
+        const disarm = () => {
+            if (watchdog !== undefined)
+                clearTimeout(watchdog);
+            watchdog = undefined;
+        };
+        const arm = () => {
+            if (idleTimeoutMs <= 0)
+                return;
+            disarm();
+            watchdog = setTimeout(() => {
+                idle.timedOut = true;
+                controller.abort();
+            }, idleTimeoutMs);
+        };
+        try {
+            arm();
+            const { options } = this;
+            const body = await untilAborted('request' in options
+                ? openStream(options.request, { body: options.body, signal })
+                : openStream(options.url, {
+                    headers: options.headers,
+                    body: options.body,
+                    signal,
+                    credentials: options.credentials,
+                }), signal);
+            if (retry > 0 && this.options.onReconnect) {
+                disarm();
+                try {
+                    await this.options.onReconnect(retry);
+                }
+                catch (err) {
+                    quietly(() => body.cancel?.());
+                    throw err;
+                }
+                if (!active()) {
+                    quietly(() => body.cancel?.());
+                    return;
                 }
-                yield parsed;
+                arm();
+            }
+            for await (const message of readLines(body, signal)) {
+                if (!active())
+                    break;
+                arm();
+                onActivity();
+                if (isHeartbeat(message))
+                    continue;
+                this.dispatch(message);
             }
         }
-        // Handle remaining buffer
-        if (buffer.trim()) {
-            const parsed = JSON.parse(buffer);
-            if (!(skipHeartbeats && parsed.type === 'heartbeat')) {
-                yield parsed;
+        finally {
+            disarm();
+        }
+    }
+    /** Route one message to onDelta, a typed event listener, onPartialData or onData. */
+    dispatch(message) {
+        const wrapper = message;
+        // Handle delta events
+        if (wrapper.event === 'delta' && this.options.onDelta) {
+            const payload = wrapper.data;
+            if (payload && payload.delta) {
+                this.options.onDelta(payload.delta, payload.seq);
+            }
+            return;
+        }
+        // Handle typed events ({"event": "...", "data": ...})
+        if (wrapper.event && this.eventListeners.has(wrapper.event)) {
+            const listeners = this.eventListeners.get(wrapper.event);
+            const eventData = wrapper.data !== undefined ? wrapper.data : message;
+            const fields = wrapper.fields;
+            listeners.forEach(callback => callback(eventData, fields));
+            return;
+        }
+        // Check if it's a partial update
+        if (typeof message === 'object' &&
+            message !== null &&
+            'data' in message &&
+            'fields' in message &&
+            Array.isArray(wrapper.fields)) {
+            if (this.options.onPartialData && wrapper.data !== undefined) {
+                this.options.onPartialData(wrapper.data, wrapper.fields);
+            }
+            else if (wrapper.data !== undefined) {
+                this.options.onData?.(wrapper.data);
             }
         }
+        else if (wrapper.data !== undefined) {
+            // Has data wrapper but no fields - unwrap
+            this.options.onData?.(wrapper.data);
+        }
+        else {
+            this.options.onData?.(message);
+        }
     }
-    finally {
-        reader.releaseLock();
+    /**
+     * Wait `delayMs` before the next attempt. In a browser, coming back online
+     * or the tab becoming visible retries at once; stop() ends the wait.
+     */
+    waitToRetry(delayMs) {
+        return new Promise((resolve) => {
+            const win = typeof window !== 'undefined' && typeof window.addEventListener === 'function' ? window : undefined;
+            const doc = typeof document !== 'undefined' && typeof document.addEventListener === 'function' ? document : undefined;
+            const onVisible = () => {
+                if (doc?.visibilityState === 'visible')
+                    wake();
+            };
+            const wake = () => {
+                clearTimeout(timer);
+                win?.removeEventListener('online', wake);
+                doc?.removeEventListener('visibilitychange', onVisible);
+                if (this.wakeRetry === wake)
+                    this.wakeRetry = null;
+                resolve();
+            };
+            const timer = setTimeout(wake, delayMs);
+            win?.addEventListener('online', wake);
+            doc?.addEventListener('visibilitychange', onVisible);
+            this.wakeRetry = wake;
+        });
+    }
+    stop() {
+        this.isRunning = false;
+        this.runId++;
+        this.abortController?.abort();
+        this.abortController = null;
+        this.wakeRetry?.();
     }
 }

package/dist/index.d.ts

@@ -1,68 +1,68 @@
-export { HttpClient, type HttpClientConfig, type ErrorHandler, type FailedRequest, type HttpFetchInit, type MessageHandler, createHttpClient } from './http/client';
-export type { Response } from './http/response';
-import type { Response } from './http/response';
-export { StreamManager, type StreamManagerOptions, type PartialDataWrapper } from './http/stream';
-export { StreamableManager, type StreamableManagerOptions, type StreamableSource, type StreamRequest, type StreamRequestInit, type StreamableMessage, streamable, streamableRaw } from './http/streamable';
-export { PollManager, type PollManagerOptions } from './http/poll';
-export { isLoopbackHost, isHttpsOrLoopback } from './http/loopback';
-export { InferenceError, RequirementsNotMetException, SessionError, SessionNotFoundError, SessionExpiredError, SessionEndedError, WorkerLostError, isRequirementsNotMetException, isInferenceError, isSessionError, } from './http/errors';
-export { TasksAPI, type RunOptions, type WatchOptions, type TaskWatch } from './api/tasks';
-export { SocketsAPI, type SocketTarget, type OpenSocketOptions } from './api/sockets';
-export { FilesAPI, type UploadFileOptions } from './api/files';
-export { AgentsAPI, Agent, type AgentOptions, type SendMessageOptions, type AgentRunOptions, type AgentDelta } from './api/agents';
-export { SessionsAPI } from './api/sessions';
-export { AppsAPI } from './api/apps';
-export { ChatsAPI } from './api/chats';
-export { FlowsAPI } from './api/flows';
-export { FlowRunsAPI } from './api/flow-runs';
-export { EnginesAPI } from './api/engines';
-export { KnowledgeAPI, SkillsAPI } from './api/knowledge';
-export { ArtifactsAPI } from './api/artifacts';
-export type { AgentUpdateBody, AppPatchBody, AppUpdateBody, ChatUpdateBody, EngineUpdateBody, FlowUpdateBody, FlowPatchBody, FlowViewportBody, ProjectWriteBody, KnowledgeUpdateBody, TeamUpdateBody, MCPServerUpdateBody, } from './api/write-bodies';
-export { TeamsAPI } from './api/teams';
-export { SecretsAPI } from './api/secrets';
-export { ApiKeysAPI } from './api/api-keys';
-export { CredentialsAPI } from './api/credentials';
-export { SearchAPI } from './api/search';
-export { ProjectsAPI } from './api/projects';
-export { MCPServersAPI } from './api/mcp-servers';
-export { LiveSession, accessUrl } from './live/session';
-export type { LiveState, LiveEnd, LiveHandlers, LiveSessionOptions, LiveUpdate, WebSocketLike, WebSocketConstructor } from './live/session';
-export { STREAM_FORMAT, CLEAR_KEY, ERROR_KEY, REDIAL_CODES } from './live/protocol';
-export { isLiveField, parseMediaType, pcmFormat, splitLiveSchema, binaryLiveField, alternativeLabel, alternativeTag, } from './live/schema';
-export type { JsonSchema, MediaType, PCMFormat, LiveField } from './live/schema';
-export { tool, appTool, agentTool, webhookTool, httpTool, callTool, mcpTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder';
-export type { ClientTool, ClientToolHandler } from './tool-builder';
-export { lifecycleHook, learningHooks } from './hook-builder';
-export type { LifecycleHookBuilder } from './hook-builder';
-export { DeltaAccumulator, createLLMDeltaAccumulator, type DeltaEvent, type FieldTags, type FieldTagsRegistry } from './delta';
-export { parseStatus, isTerminalStatus, isChatBusy, isAwaitingHuman, isRunTerminal, isRunInterrupted, isRunSettled, isRunWorking, isMessageTerminal, pendingApprovals, } from './utils';
-export type { PendingApproval } from './utils';
-export * from './types';
-export type { TaskDTO as Task } from './types';
-import { HttpClient, type HttpClientConfig } from './http/client';
-import { TasksAPI, RunOptions } from './api/tasks';
-import { SocketsAPI } from './api/sockets';
-import { LiveSession, type LiveHandlers } from './live/session';
-import type { OpenSocketOptions } from './api/sockets';
-import { FilesAPI, UploadFileOptions } from './api/files';
-import { AgentsAPI, Agent, AgentOptions } from './api/agents';
-import { SessionsAPI } from './api/sessions';
-import { AppsAPI } from './api/apps';
-import { ChatsAPI } from './api/chats';
-import { FlowsAPI } from './api/flows';
-import { FlowRunsAPI } from './api/flow-runs';
-import { EnginesAPI } from './api/engines';
-import { KnowledgeAPI, SkillsAPI } from './api/knowledge';
-import { ArtifactsAPI } from './api/artifacts';
-import { TeamsAPI } from './api/teams';
-import { SecretsAPI } from './api/secrets';
-import { ApiKeysAPI } from './api/api-keys';
-import { CredentialsAPI } from './api/credentials';
-import { SearchAPI } from './api/search';
-import { ProjectsAPI } from './api/projects';
-import { MCPServersAPI } from './api/mcp-servers';
-import { ApiAppRunRequest, TaskDTO as Task, AgentConfigInput as AgentConfig, FileDTO as File } from './types';
+export { HttpClient, type HttpClientConfig, type ErrorHandler, type FailedRequest, type HttpFetchInit, type MessageHandler, createHttpClient } from './http/client.js';
+export type { Response } from './http/response.js';
+import type { Response } from './http/response.js';
+export { StreamManager, type StreamManagerOptions, type PartialDataWrapper } from './http/stream.js';
+export { StreamableManager, type StreamableManagerOptions, type StreamReconnectOptions, type StreamableSource, type StreamRequest, type StreamRequestInit, type StreamableMessage, streamable, streamableRaw } from './http/streamable.js';
+export { PollManager, type PollManagerOptions } from './http/poll.js';
+export { isLoopbackHost, isHttpsOrLoopback } from './http/loopback.js';
+export { InferenceError, RequirementsNotMetException, SessionError, SessionNotFoundError, SessionExpiredError, SessionEndedError, WorkerLostError, isRequirementsNotMetException, isInferenceError, isSessionError, } from './http/errors.js';
+export { TasksAPI, type RunOptions, type WatchOptions, type TaskWatch } from './api/tasks.js';
+export { SocketsAPI, type SocketTarget, type OpenSocketOptions } from './api/sockets.js';
+export { FilesAPI, type UploadFileOptions } from './api/files.js';
+export { AgentsAPI, Agent, type AgentOptions, type SendMessageOptions, type AgentRunOptions, type AgentDelta } from './api/agents.js';
+export { SessionsAPI } from './api/sessions.js';
+export { AppsAPI } from './api/apps.js';
+export { ChatsAPI } from './api/chats.js';
+export { FlowsAPI } from './api/flows.js';
+export { FlowRunsAPI } from './api/flow-runs.js';
+export { EnginesAPI } from './api/engines.js';
+export { KnowledgeAPI, SkillsAPI } from './api/knowledge.js';
+export { ArtifactsAPI } from './api/artifacts.js';
+export type { AgentUpdateBody, AppPatchBody, AppUpdateBody, ChatUpdateBody, EngineUpdateBody, FlowUpdateBody, FlowPatchBody, FlowViewportBody, ProjectWriteBody, KnowledgeUpdateBody, TeamUpdateBody, MCPServerUpdateBody, } from './api/write-bodies.js';
+export { TeamsAPI } from './api/teams.js';
+export { SecretsAPI } from './api/secrets.js';
+export { ApiKeysAPI } from './api/api-keys.js';
+export { CredentialsAPI } from './api/credentials.js';
+export { SearchAPI } from './api/search.js';
+export { ProjectsAPI } from './api/projects.js';
+export { MCPServersAPI } from './api/mcp-servers.js';
+export { LiveSession, accessUrl } from './live/session.js';
+export type { LiveState, LiveEnd, LiveHandlers, LiveSessionOptions, LiveUpdate, WebSocketLike, WebSocketConstructor } from './live/session.js';
+export { STREAM_FORMAT, CLEAR_KEY, ERROR_KEY, REDIAL_CODES } from './live/protocol.js';
+export { isLiveField, parseMediaType, pcmFormat, splitLiveSchema, binaryLiveField, alternativeLabel, alternativeTag, } from './live/schema.js';
+export type { JsonSchema, MediaType, PCMFormat, LiveField } from './live/schema.js';
+export { tool, appTool, agentTool, webhookTool, httpTool, callTool, mcpTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional, } from './tool-builder.js';
+export type { ClientTool, ClientToolHandler } from './tool-builder.js';
+export { lifecycleHook, learningHooks } from './hook-builder.js';
+export type { LifecycleHookBuilder } from './hook-builder.js';
+export { DeltaAccumulator, createLLMDeltaAccumulator, type DeltaEvent, type FieldTags, type FieldTagsRegistry } from './delta.js';
+export { parseStatus, isTerminalStatus, isChatBusy, isAwaitingHuman, isRunTerminal, isRunInterrupted, isRunSettled, isRunWorking, isMessageTerminal, pendingApprovals, } from './utils.js';
+export type { PendingApproval } from './utils.js';
+export * from './types.js';
+export type { TaskDTO as Task } from './types.js';
+import { HttpClient, type HttpClientConfig } from './http/client.js';
+import { TasksAPI, RunOptions } from './api/tasks.js';
+import { SocketsAPI } from './api/sockets.js';
+import { LiveSession, type LiveHandlers } from './live/session.js';
+import type { OpenSocketOptions } from './api/sockets.js';
+import { FilesAPI, UploadFileOptions } from './api/files.js';
+import { AgentsAPI, Agent, AgentOptions } from './api/agents.js';
+import { SessionsAPI } from './api/sessions.js';
+import { AppsAPI } from './api/apps.js';
+import { ChatsAPI } from './api/chats.js';
+import { FlowsAPI } from './api/flows.js';
+import { FlowRunsAPI } from './api/flow-runs.js';
+import { EnginesAPI } from './api/engines.js';
+import { KnowledgeAPI, SkillsAPI } from './api/knowledge.js';
+import { ArtifactsAPI } from './api/artifacts.js';
+import { TeamsAPI } from './api/teams.js';
+import { SecretsAPI } from './api/secrets.js';
+import { ApiKeysAPI } from './api/api-keys.js';
+import { CredentialsAPI } from './api/credentials.js';
+import { SearchAPI } from './api/search.js';
+import { ProjectsAPI } from './api/projects.js';
+import { MCPServersAPI } from './api/mcp-servers.js';
+import { ApiAppRunRequest, TaskDTO as Task, AgentConfigInput as AgentConfig, FileDTO as File } from './types.js';
 export interface InferenceConfig {
     /** Your inference.sh API key (required unless using proxyUrl) */
     apiKey?: string;