@inferencesh/sdk 0.1.1 → 0.2.0

package/dist/client.js

@@ -1,9 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.inference = exports.Inference = void 0;
+exports.Agent = exports.Inference = void 0;
+exports.inference = inference;
 const types_1 = require("./types");
 const stream_1 = require("./stream");
 const eventsource_1 = require("eventsource");
+const errors_1 = require("./errors");
 /**
  * Inference.sh SDK Client
  *
@@ -21,7 +23,8 @@ class Inference {
         this.apiKey = config.apiKey;
         this.baseUrl = config.baseUrl || "https://api.inference.sh";
     }
-    async request(method, endpoint, options = {}) {
+    /** @internal */
+    async _request(method, endpoint, options = {}) {
         const url = new URL(`${this.baseUrl}${endpoint}`);
         if (options.params) {
             Object.entries(options.params).forEach(([key, value]) => {
@@ -43,13 +46,48 @@ class Inference {
             fetchOptions.body = JSON.stringify(options.data);
         }
         const response = await fetch(url.toString(), fetchOptions);
-        const data = await response.json();
-        if (!data.success) {
-            throw new Error(data.error?.message || "Request failed");
+        const responseText = await response.text();
+        // Try to parse as JSON
+        let data = null;
+        try {
+            data = JSON.parse(responseText);
         }
-        return data.data;
+        catch {
+            // Not JSON
+        }
+        // Check for HTTP errors
+        if (!response.ok) {
+            // Check for RequirementsNotMetException (412 with errors array)
+            if (response.status === 412 && data && 'errors' in data && Array.isArray(data.errors)) {
+                throw errors_1.RequirementsNotMetException.fromResponse(data, response.status);
+            }
+            // General error handling
+            let errorDetail;
+            if (data && typeof data === 'object') {
+                const apiData = data;
+                if (apiData.error) {
+                    errorDetail = typeof apiData.error === 'object' ? apiData.error.message : String(apiData.error);
+                }
+                else if ('message' in data) {
+                    errorDetail = String(data.message);
+                }
+                else {
+                    errorDetail = JSON.stringify(data);
+                }
+            }
+            else if (responseText) {
+                errorDetail = responseText.slice(0, 500);
+            }
+            throw new errors_1.InferenceError(response.status, errorDetail || 'Request failed', responseText);
+        }
+        const apiResponse = data;
+        if (!apiResponse?.success) {
+            throw new errors_1.InferenceError(response.status, apiResponse?.error?.message || 'Request failed', responseText);
+        }
+        return apiResponse.data;
     }
-    createEventSource(endpoint) {
+    /** @internal */
+    _createEventSource(endpoint) {
         const url = new URL(`${this.baseUrl}${endpoint}`);
         return new eventsource_1.EventSource(url.toString(), {
             fetch: (input, init) => fetch(input, {
@@ -112,26 +150,37 @@ class Inference {
      * @param options - Run options for waiting, updates, and reconnection
      * @returns The completed task result
      *
+     * App reference format: `namespace/name@shortid` (version is required)
+     *
+     * The short ID ensures your code always runs the same version,
+     * protecting against breaking changes from app updates.
+     *
      * @example
      * ```typescript
-     * // Simple usage - wait for result
-     * const result = await client.run({ app: 'my-app', input: { prompt: 'hello' } });
+     * // Run a specific version (required)
+     * const result = await client.run({
+     *   app: 'okaris/flux@abc1',  // version @abc1 is pinned
+     *   input: { prompt: 'hello' }
+     * });
      *
      * // With status updates
      * const result = await client.run(
-     *   { app: 'my-app', input: { prompt: 'hello' } },
+     *   { app: 'okaris/flux@abc1', input: { prompt: 'hello' } },
      *   { onUpdate: (update) => console.log(update.status) }
      * );
      *
      * // Fire and forget
-     * const task = await client.run({ app: 'my-app', input: {} }, { wait: false });
+     * const task = await client.run(
+     *   { app: 'okaris/flux@abc1', input: {} },
+     *   { wait: false }
+     * );
      * ```
      */
     async run(params, options = {}) {
         const { onUpdate, onPartialUpdate, wait = true, autoReconnect = true, maxReconnects = 5, reconnectDelayMs = 1000, } = options;
         // Process input data and upload any files
         const processedInput = await this.processInputData(params.input);
-        const task = await this.request("post", "/run", {
+        const task = await this._request("post", "/apps/run", {
             data: {
                 ...params,
                 input: processedInput
@@ -144,7 +193,7 @@ class Inference {
         // Wait for completion with optional updates
         return new Promise((resolve, reject) => {
             const streamManager = new stream_1.StreamManager({
-                createEventSource: async () => this.createEventSource(`/tasks/${task.id}/stream`),
+                createEventSource: async () => this._createEventSource(`/tasks/${task.id}/stream`),
                 autoReconnect,
                 maxReconnects,
                 reconnectDelayMs,
@@ -189,7 +238,7 @@ class Inference {
             path: options.path,
             size: data instanceof Blob ? data.size : undefined,
         };
-        const response = await this.request("post", "/files", {
+        const response = await this._request("post", "/files", {
             data: {
                 files: [fileRequest]
             }
@@ -246,11 +295,159 @@ class Inference {
        * @param taskId - The ID of the task to cancel
        */
     async cancel(taskId) {
-        return this.request("post", `/tasks/${taskId}/cancel`);
+        return this._request("post", `/tasks/${taskId}/cancel`);
+    }
+    /**
+     * Create an agent for chat interactions
+     *
+     * @param config - Either a template reference string (namespace/name@version) or ad-hoc config
+     * @returns An Agent instance for chat operations
+     *
+     * @example
+     * ```typescript
+     * // Template agent
+     * const agent = client.agent('okaris/assistant@abc123')
+     *
+     * // Ad-hoc agent
+     * const agent = client.agent({
+     *   coreApp: 'infsh/claude-sonnet-4@xyz789',
+     *   systemPrompt: 'You are a helpful assistant',
+     *   tools: [...]
+     * })
+     *
+     * // Send messages
+     * const response = await agent.sendMessage('Hello!')
+     * ```
+     */
+    agent(config) {
+        return new Agent(this, config);
     }
 }
 exports.Inference = Inference;
+// =============================================================================
+// Agent Class
+// =============================================================================
 /**
- * @deprecated Use `Inference` instead. Will be removed in v1.0.0
+ * Agent for chat interactions
+ *
+ * Created via `client.agent()` - do not instantiate directly.
  */
-exports.inference = Inference;
+class Agent {
+    /** @internal */
+    constructor(client, config) {
+        this.chatId = null;
+        this.stream = null;
+        this.client = client;
+        this.config = config;
+    }
+    /** Get current chat ID */
+    get currentChatId() {
+        return this.chatId;
+    }
+    /** Send a message to the agent */
+    async sendMessage(text, options = {}) {
+        const isTemplate = typeof this.config === 'string';
+        // Upload files if provided
+        let imageUri;
+        let fileUris;
+        if (options.files && options.files.length > 0) {
+            const uploadedFiles = await Promise.all(options.files.map(f => this.client.uploadFile(f)));
+            const images = uploadedFiles.filter(f => f.content_type?.startsWith('image/'));
+            const others = uploadedFiles.filter(f => !f.content_type?.startsWith('image/'));
+            if (images.length > 0)
+                imageUri = images[0].uri;
+            if (others.length > 0)
+                fileUris = others.map(f => f.uri);
+        }
+        const body = isTemplate
+            ? {
+                chat_id: this.chatId,
+                agent: this.config,
+                input: { text, image: imageUri, files: fileUris, role: 'user', context: [], system_prompt: '', context_size: 0 },
+            }
+            : {
+                chat_id: this.chatId,
+                core_app: this.config.coreApp,
+                core_app_input: this.config.coreAppInput,
+                name: this.config.name,
+                system_prompt: this.config.systemPrompt,
+                tools: this.config.tools,
+                internal_tools: this.config.internalTools,
+                input: { text, image: imageUri, files: fileUris, role: 'user', context: [], system_prompt: '', context_size: 0 },
+            };
+        const response = await this.client._request('post', '/agents/run', { data: body });
+        if (!this.chatId && response.assistant_message.chat_id) {
+            this.chatId = response.assistant_message.chat_id;
+            this.startStreaming(options);
+        }
+        return response.assistant_message;
+    }
+    /** Get chat by ID */
+    async getChat(chatId) {
+        const id = chatId || this.chatId;
+        if (!id)
+            return null;
+        return this.client._request('get', `/chats/${id}`);
+    }
+    /** Stop the current chat generation */
+    async stopChat() {
+        if (!this.chatId)
+            return;
+        await this.client._request('post', `/chats/${this.chatId}/stop`);
+    }
+    /** Submit a tool result */
+    async submitToolResult(toolInvocationId, result) {
+        if (!this.chatId)
+            throw new Error('No active chat');
+        await this.client._request('post', `/chats/${this.chatId}/tool-result`, {
+            data: { tool_invocation_id: toolInvocationId, result },
+        });
+    }
+    /** Stop streaming and cleanup */
+    disconnect() {
+        this.stream?.stop();
+        this.stream = null;
+    }
+    /** Reset the agent (start fresh chat) */
+    reset() {
+        this.disconnect();
+        this.chatId = null;
+    }
+    startStreaming(options) {
+        if (!this.chatId)
+            return;
+        this.stream = new stream_1.StreamManager({
+            createEventSource: async () => this.client._createEventSource(`/chats/${this.chatId}/stream`),
+            autoReconnect: true,
+        });
+        this.stream.addEventListener('chats', (chat) => {
+            options.onChat?.(chat);
+        });
+        this.stream.addEventListener('chat_messages', (message) => {
+            options.onMessage?.(message);
+            if (message.tool_invocations && options.onToolCall) {
+                for (const inv of message.tool_invocations) {
+                    if (inv.type === types_1.ToolTypeClient && inv.status === types_1.ToolInvocationStatusAwaitingInput) {
+                        options.onToolCall({
+                            id: inv.id,
+                            name: inv.function?.name || '',
+                            args: inv.function?.arguments || {},
+                        });
+                    }
+                }
+            }
+        });
+        this.stream.connect();
+    }
+}
+exports.Agent = Agent;
+/**
+ * Factory function for creating an Inference client (lowercase for branding)
+ * @example
+ * ```typescript
+ * const client = inference({ apiKey: 'your-api-key' });
+ * ```
+ */
+function inference(config) {
+    return new Inference(config);
+}

package/dist/client.test.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const client_1 = require("./client");
+const errors_1 = require("./errors");
 // Mock fetch globally
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
@@ -39,8 +40,12 @@ describe('Inference', () => {
                 input: { message: 'hello world' },
                 output: { result: 'success' },
             };
+            const responseData = { success: true, data: mockTask };
             mockFetch.mockResolvedValueOnce({
-                json: () => Promise.resolve({ success: true, data: mockTask }),
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(responseData)),
+                json: () => Promise.resolve(responseData),
             });
             const client = new client_1.Inference({ apiKey: 'test-api-key' });
             // Use input that won't trigger base64 detection (contains spaces/special chars)
@@ -55,29 +60,107 @@ describe('Inference', () => {
             }));
         });
         it('should throw error on API failure', async () => {
+            const responseData = { success: false, error: { message: 'Invalid app' } };
             mockFetch.mockResolvedValueOnce({
-                json: () => Promise.resolve({ success: false, error: { message: 'Invalid app' } }),
+                ok: false,
+                status: 400,
+                text: () => Promise.resolve(JSON.stringify(responseData)),
+                json: () => Promise.resolve(responseData),
             });
             const client = new client_1.Inference({ apiKey: 'test-api-key' });
             await expect(client.run({ app: 'invalid-app', input: { message: 'test!' } }, { wait: false })).rejects.toThrow('Invalid app');
         });
+        it('should throw RequirementsNotMetException on 412 with errors', async () => {
+            const requirementErrors = [
+                {
+                    type: 'secret',
+                    key: 'OPENAI_API_KEY',
+                    message: 'Missing secret: OPENAI_API_KEY',
+                    action: { type: 'add_secret', secret_key: 'OPENAI_API_KEY' },
+                },
+                {
+                    type: 'integration',
+                    key: 'google',
+                    message: 'Integration not connected: google',
+                    action: { type: 'connect', provider: 'google' },
+                },
+            ];
+            const responseData = { errors: requirementErrors };
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 412,
+                text: () => Promise.resolve(JSON.stringify(responseData)),
+                json: () => Promise.resolve(responseData),
+            });
+            const client = new client_1.Inference({ apiKey: 'test-api-key' });
+            try {
+                await client.run({ app: 'test-app', input: { message: 'test!' } }, { wait: false });
+                fail('Expected RequirementsNotMetException to be thrown');
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(errors_1.RequirementsNotMetException);
+                const exception = e;
+                expect(exception.errors).toHaveLength(2);
+                expect(exception.errors[0].type).toBe('secret');
+                expect(exception.errors[0].key).toBe('OPENAI_API_KEY');
+                expect(exception.errors[1].type).toBe('integration');
+                expect(exception.statusCode).toBe(412);
+                expect(exception.message).toBe('Missing secret: OPENAI_API_KEY');
+            }
+        });
+        it('should include action details in RequirementsNotMetException', async () => {
+            const requirementErrors = [
+                {
+                    type: 'scope',
+                    key: 'calendar.readonly',
+                    message: 'Missing scope: calendar.readonly',
+                    action: {
+                        type: 'add_scopes',
+                        provider: 'google',
+                        scopes: ['calendar.readonly', 'calendar.events'],
+                    },
+                },
+            ];
+            const responseData = { errors: requirementErrors };
+            mockFetch.mockResolvedValueOnce({
+                ok: false,
+                status: 412,
+                text: () => Promise.resolve(JSON.stringify(responseData)),
+                json: () => Promise.resolve(responseData),
+            });
+            const client = new client_1.Inference({ apiKey: 'test-api-key' });
+            try {
+                await client.run({ app: 'test-app', input: {} }, { wait: false });
+                fail('Expected RequirementsNotMetException to be thrown');
+            }
+            catch (e) {
+                expect(e).toBeInstanceOf(errors_1.RequirementsNotMetException);
+                const exception = e;
+                expect(exception.errors[0].action?.type).toBe('add_scopes');
+                expect(exception.errors[0].action?.scopes).toEqual(['calendar.readonly', 'calendar.events']);
+            }
+        });
     });
     describe('cancel', () => {
         it('should make a POST request to cancel endpoint', async () => {
+            const responseData = { success: true, data: null };
             mockFetch.mockResolvedValueOnce({
-                json: () => Promise.resolve({ success: true, data: null }),
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(responseData)),
+                json: () => Promise.resolve(responseData),
             });
             const client = new client_1.Inference({ apiKey: 'test-api-key' });
             await client.cancel('task-123');
             expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/tasks/task-123/cancel'), expect.objectContaining({ method: 'POST' }));
         });
     });
-    describe('backward compatibility', () => {
-        it('should export lowercase inference as alias', () => {
-            expect(client_1.inference).toBe(client_1.Inference);
+    describe('lowercase factory', () => {
+        it('should export lowercase inference factory', () => {
+            expect(typeof client_1.inference).toBe('function');
         });
-        it('should work with lowercase inference', () => {
-            const client = new client_1.inference({ apiKey: 'test-api-key' });
+        it('should work with lowercase inference factory', () => {
+            const client = (0, client_1.inference)({ apiKey: 'test-api-key' });
             expect(client).toBeInstanceOf(client_1.Inference);
         });
     });
@@ -92,9 +175,13 @@ describe('uploadFile', () => {
             uri: 'https://example.com/file.png',
             upload_url: 'https://upload.example.com/signed-url',
         };
+        const responseData = { success: true, data: [mockFile] };
         mockFetch
             .mockResolvedValueOnce({
-            json: () => Promise.resolve({ success: true, data: [mockFile] }),
+            ok: true,
+            status: 200,
+            text: () => Promise.resolve(JSON.stringify(responseData)),
+            json: () => Promise.resolve(responseData),
         })
             .mockResolvedValueOnce({ ok: true });
         const client = new client_1.Inference({ apiKey: 'test-api-key' });
@@ -112,8 +199,12 @@ describe('uploadFile', () => {
             uri: 'https://example.com/file.png',
             // Missing upload_url
         };
+        const responseData = { success: true, data: [mockFile] };
         mockFetch.mockResolvedValueOnce({
-            json: () => Promise.resolve({ success: true, data: [mockFile] }),
+            ok: true,
+            status: 200,
+            text: () => Promise.resolve(JSON.stringify(responseData)),
+            json: () => Promise.resolve(responseData),
         });
         const client = new client_1.Inference({ apiKey: 'test-api-key' });
         await expect(client.uploadFile('SGVsbG8gV29ybGQh', { filename: 'test.txt' })).rejects.toThrow('No upload URL provided by the server');

package/dist/errors.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Error classes for the inference.sh SDK.
+ *
+ * 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';
+/**
+ * General HTTP/API error thrown by the SDK.
+ *
+ * Note: This is distinct from the `APIError` interface in types.ts which describes
+ * the error payload shape in API responses.
+ */
+export declare class InferenceError extends Error {
+    readonly statusCode: number;
+    readonly responseBody?: string;
+    constructor(statusCode: number, message: string, responseBody?: string);
+}
+/**
+ * Error thrown when app requirements (secrets, integrations, scopes) are not met.
+ *
+ * Thrown for HTTP 412 responses that contain structured requirement errors.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const task = await client.run(params);
+ * } catch (e) {
+ *   if (e instanceof RequirementsNotMetException) {
+ *     for (const err of e.errors) {
+ *       console.log(`Missing ${err.type}: ${err.key}`);
+ *       if (err.action) {
+ *         console.log(`  Fix: ${err.action.type}`);
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare class RequirementsNotMetException extends Error {
+    readonly errors: RequirementError[];
+    readonly statusCode: number;
+    constructor(errors: RequirementError[], statusCode?: number);
+    /**
+     * Create from API response data.
+     */
+    static fromResponse(data: {
+        errors?: RequirementError[];
+    }, statusCode?: number): RequirementsNotMetException;
+}

package/dist/errors.js

@@ -0,0 +1,61 @@
+"use strict";
+/**
+ * Error classes for the inference.sh SDK.
+ *
+ * Note: types.ts contains interfaces (APIError, RequirementsNotMetError) that describe
+ * the API response data shapes. These classes are throwable Error subclasses for SDK use.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequirementsNotMetException = exports.InferenceError = void 0;
+/**
+ * General HTTP/API error thrown by the SDK.
+ *
+ * Note: This is distinct from the `APIError` interface in types.ts which describes
+ * the error payload shape in API responses.
+ */
+class InferenceError extends Error {
+    constructor(statusCode, message, responseBody) {
+        super(`HTTP ${statusCode}: ${message}`);
+        this.name = 'InferenceError';
+        this.statusCode = statusCode;
+        this.responseBody = responseBody;
+    }
+}
+exports.InferenceError = InferenceError;
+/**
+ * Error thrown when app requirements (secrets, integrations, scopes) are not met.
+ *
+ * Thrown for HTTP 412 responses that contain structured requirement errors.
+ *
+ * @example
+ * ```typescript
+ * try {
+ *   const task = await client.run(params);
+ * } catch (e) {
+ *   if (e instanceof RequirementsNotMetException) {
+ *     for (const err of e.errors) {
+ *       console.log(`Missing ${err.type}: ${err.key}`);
+ *       if (err.action) {
+ *         console.log(`  Fix: ${err.action.type}`);
+ *       }
+ *     }
+ *   }
+ * }
+ * ```
+ */
+class RequirementsNotMetException extends Error {
+    constructor(errors, statusCode = 412) {
+        const message = errors.length > 0 ? errors[0].message : 'requirements not met';
+        super(message);
+        this.name = 'RequirementsNotMetException';
+        this.errors = errors;
+        this.statusCode = statusCode;
+    }
+    /**
+     * Create from API response data.
+     */
+    static fromResponse(data, statusCode = 412) {
+        return new RequirementsNotMetException(data.errors || [], statusCode);
+    }
+}
+exports.RequirementsNotMetException = RequirementsNotMetException;

package/dist/index.d.ts

@@ -1,4 +1,7 @@
-export { Inference, inference, InferenceConfig, RunOptions, UploadFileOptions } from './client';
+export { Inference, inference, InferenceConfig, RunOptions, UploadFileOptions, Agent, AdHocAgentConfig, SendMessageOptions, } from './client';
+export { AgentConfig, AdHocAgentOptions, TemplateAgentOptions, AgentOptions, } from './agent';
+export { tool, appTool, agentTool, webhookTool, internalTools, string, number, integer, boolean, enumOf, object, array, optional } from './tool-builder';
 export { StreamManager, PartialDataWrapper } from './stream';
+export { InferenceError, RequirementsNotMetException } from './errors';
 export * from './types';
 export type { TaskDTO as Task } from './types';

package/dist/index.js

@@ -14,13 +14,33 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StreamManager = exports.inference = exports.Inference = void 0;
-// Main client export
+exports.RequirementsNotMetException = exports.InferenceError = exports.StreamManager = exports.optional = exports.array = exports.object = exports.enumOf = exports.boolean = exports.integer = exports.number = exports.string = exports.internalTools = exports.webhookTool = exports.agentTool = exports.appTool = exports.tool = exports.Agent = exports.inference = exports.Inference = void 0;
+// Main client export (includes Agent)
 var client_1 = require("./client");
 Object.defineProperty(exports, "Inference", { enumerable: true, get: function () { return client_1.Inference; } });
 Object.defineProperty(exports, "inference", { enumerable: true, get: function () { return client_1.inference; } });
+Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return client_1.Agent; } });
+// Tool Builder (fluent API)
+var tool_builder_1 = require("./tool-builder");
+Object.defineProperty(exports, "tool", { enumerable: true, get: function () { return tool_builder_1.tool; } });
+Object.defineProperty(exports, "appTool", { enumerable: true, get: function () { return tool_builder_1.appTool; } });
+Object.defineProperty(exports, "agentTool", { enumerable: true, get: function () { return tool_builder_1.agentTool; } });
+Object.defineProperty(exports, "webhookTool", { enumerable: true, get: function () { return tool_builder_1.webhookTool; } });
+Object.defineProperty(exports, "internalTools", { enumerable: true, get: function () { return tool_builder_1.internalTools; } });
+Object.defineProperty(exports, "string", { enumerable: true, get: function () { return tool_builder_1.string; } });
+Object.defineProperty(exports, "number", { enumerable: true, get: function () { return tool_builder_1.number; } });
+Object.defineProperty(exports, "integer", { enumerable: true, get: function () { return tool_builder_1.integer; } });
+Object.defineProperty(exports, "boolean", { enumerable: true, get: function () { return tool_builder_1.boolean; } });
+Object.defineProperty(exports, "enumOf", { enumerable: true, get: function () { return tool_builder_1.enumOf; } });
+Object.defineProperty(exports, "object", { enumerable: true, get: function () { return tool_builder_1.object; } });
+Object.defineProperty(exports, "array", { enumerable: true, get: function () { return tool_builder_1.array; } });
+Object.defineProperty(exports, "optional", { enumerable: true, get: function () { return tool_builder_1.optional; } });
 // Stream utilities
 var stream_1 = require("./stream");
 Object.defineProperty(exports, "StreamManager", { enumerable: true, get: function () { return stream_1.StreamManager; } });
+// Error classes (throwable)
+var errors_1 = require("./errors");
+Object.defineProperty(exports, "InferenceError", { enumerable: true, get: function () { return errors_1.InferenceError; } });
+Object.defineProperty(exports, "RequirementsNotMetException", { enumerable: true, get: function () { return errors_1.RequirementsNotMetException; } });
 // Types - includes TaskStatus constants and all DTOs
 __exportStar(require("./types"), exports);

package/dist/stream.d.ts

@@ -24,7 +24,15 @@ export declare class StreamManager<T> {
     private initialConnectionAttempts;
     private isConnected;
     private isStopped;
+    private eventListeners;
     constructor(options: StreamManagerOptions<T>);
+    /**
+     * Add a listener for typed SSE events (e.g., 'chats', 'chat_messages')
+     * Used when server sends events with `event: eventName` header
+     */
+    addEventListener<E = unknown>(eventName: string, callback: (data: E) => void): () => void;
+    private setupEventListener;
+    private setupAllEventListeners;
     private clearTimeouts;
     private closeEventSource;
     private cleanup;