@inferencesh/sdk 0.6.14 → 0.6.19

package/dist/sessions.integration.test.js

@@ -1,310 +0,0 @@
-/**
- * Sessions integration tests for @inferencesh/sdk
- *
- * These tests hit the real API and require INFERENCE_API_KEY to be set.
- * Run with: npm run test:integration
- *
- * Prerequisites:
- *   - API and scheduler must be running
- *   - Test app deployed: infsh/session-test
- *
- * @jest-environment node
- */
-import { Inference } from './index';
-import { TaskStatusCompleted } from './types';
-const API_KEY = process.env.INFERENCE_API_KEY;
-const BASE_URL = process.env.INFERENCE_BASE_URL || 'https://api.inference.sh';
-// Session test app with multi-function support
-const SESSION_TEST_APP = 'infsh/session-test';
-const describeIfApiKey = API_KEY ? describe : describe.skip;
-describeIfApiKey('Sessions Integration Tests', () => {
-    let client;
-    beforeAll(() => {
-        client = new Inference({
-            apiKey: API_KEY,
-            baseUrl: BASE_URL,
-        });
-    });
-    // ==========================================================================
-    // Session Creation Tests
-    // ==========================================================================
-    describe('Session Creation', () => {
-        it('should create a new session and return real session ID', async () => {
-            const result = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'test_create', value: 'hello' },
-                session: 'new',
-            });
-            expect(result.status).toBe(TaskStatusCompleted);
-            expect(result.session_id).toBeDefined();
-            expect(result.session_id).not.toBe('new');
-        }, 60000);
-        it('should return correct output data', async () => {
-            const result = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'output_test', value: 'test_value' },
-                session: 'new',
-            });
-            expect(result.status).toBe(TaskStatusCompleted);
-            const output = result.output;
-            expect(output.success).toBe(true);
-            expect(output.key).toBe('output_test');
-            expect(output.value).toBe('test_value');
-        }, 60000);
-    });
-    // ==========================================================================
-    // Session Continuity Tests
-    // ==========================================================================
-    describe('Session Continuity', () => {
-        it('should persist state across calls in same session', async () => {
-            // Create session with initial value
-            const result1 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'persist_key', value: 'persist_value' },
-                session: 'new',
-            });
-            expect(result1.status).toBe(TaskStatusCompleted);
-            const sessionId = result1.session_id;
-            // Retrieve value from same session
-            const result2 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'get_value',
-                input: { key: 'persist_key' },
-                session: sessionId,
-            });
-            expect(result2.status).toBe(TaskStatusCompleted);
-            expect(result2.session_id).toBe(sessionId);
-            const output = result2.output;
-            expect(output.found).toBe(true);
-            expect(output.value).toBe('persist_value');
-        }, 120000);
-        it('should accumulate multiple values in session', async () => {
-            // Create session
-            const result1 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'key1', value: 'value1' },
-                session: 'new',
-            });
-            expect(result1.status).toBe(TaskStatusCompleted);
-            const sessionId = result1.session_id;
-            // Add second value
-            const result2 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'key2', value: 'value2' },
-                session: sessionId,
-            });
-            expect(result2.status).toBe(TaskStatusCompleted);
-            // Get all state
-            const result3 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'get_all',
-                input: {},
-                session: sessionId,
-            });
-            expect(result3.status).toBe(TaskStatusCompleted);
-            const output = result3.output;
-            expect(output.state.key1).toBe('value1');
-            expect(output.state.key2).toBe('value2');
-        }, 120000);
-    });
-    // ==========================================================================
-    // Multi-Function Routing Tests
-    // ==========================================================================
-    describe('Multi-Function Routing', () => {
-        it('should route to increment function correctly', async () => {
-            const result = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'increment',
-                input: { key: 'counter', amount: 5 },
-                session: 'new',
-            });
-            expect(result.status).toBe(TaskStatusCompleted);
-            const output = result.output;
-            expect(output.key).toBe('counter');
-            expect(output.previous).toBe(0);
-            expect(output.current).toBe(5);
-        }, 60000);
-        it('should handle different input schemas per function', async () => {
-            // Create session
-            const result1 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'schema_test', value: 'v1' },
-                session: 'new',
-            });
-            expect(result1.status).toBe(TaskStatusCompleted);
-            const sessionId = result1.session_id;
-            // get_value has different schema (no 'value' field)
-            const result2 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'get_value',
-                input: { key: 'schema_test' },
-                session: sessionId,
-            });
-            expect(result2.status).toBe(TaskStatusCompleted);
-            // increment has different schema (amount field)
-            const result3 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'increment',
-                input: { key: 'cnt', amount: 10 },
-                session: sessionId,
-            });
-            expect(result3.status).toBe(TaskStatusCompleted);
-            // get_all has empty schema
-            const result4 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'get_all',
-                input: {},
-                session: sessionId,
-            });
-            expect(result4.status).toBe(TaskStatusCompleted);
-        }, 120000);
-    });
-    // ==========================================================================
-    // Session Isolation Tests
-    // ==========================================================================
-    describe('Session Isolation', () => {
-        it('should create different sessions for different "new" requests', async () => {
-            // Create first session
-            const result1 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'isolated', value: 'session1' },
-                session: 'new',
-            });
-            expect(result1.status).toBe(TaskStatusCompleted);
-            const session1 = result1.session_id;
-            // Create second session
-            const result2 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'isolated', value: 'session2' },
-                session: 'new',
-            });
-            expect(result2.status).toBe(TaskStatusCompleted);
-            const session2 = result2.session_id;
-            // Sessions should be different
-            expect(session1).not.toBe(session2);
-        }, 120000);
-    });
-    // ==========================================================================
-    // Sessions API Tests
-    // ==========================================================================
-    describe('Sessions API', () => {
-        it('should get session info', async () => {
-            // Create a session
-            const result = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'api_test', value: 'hello' },
-                session: 'new',
-            });
-            expect(result.status).toBe(TaskStatusCompleted);
-            const sessionId = result.session_id;
-            // Get session info via API
-            const sessionInfo = await client.sessions.get(sessionId);
-            // API returns flattened structure (Go embedded structs)
-            expect(sessionInfo.id).toBe(sessionId);
-            expect(sessionInfo.status).toBe('active');
-            expect(sessionInfo.call_count).toBeGreaterThanOrEqual(1);
-        }, 60000);
-        it('should list sessions', async () => {
-            const sessions = await client.sessions.list();
-            expect(Array.isArray(sessions)).toBe(true);
-            // Should have at least one session from previous tests
-        }, 30000);
-        it('should keepalive a session', async () => {
-            // Create a session
-            const result = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'keepalive_test', value: 'hello' },
-                session: 'new',
-            });
-            expect(result.status).toBe(TaskStatusCompleted);
-            const sessionId = result.session_id;
-            // Keepalive
-            const updated = await client.sessions.keepalive(sessionId);
-            // API returns flattened structure (Go embedded structs)
-            expect(updated.id).toBe(sessionId);
-            expect(updated.status).toBe('active');
-        }, 60000);
-        it('should end a session', async () => {
-            // Create a session
-            const result = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'end_test', value: 'goodbye' },
-                session: 'new',
-            });
-            expect(result.status).toBe(TaskStatusCompleted);
-            const sessionId = result.session_id;
-            // End the session
-            await client.sessions.end(sessionId);
-            // Trying to use ended session should fail
-            await expect(client.run({
-                app: SESSION_TEST_APP,
-                function: 'get_value',
-                input: { key: 'end_test' },
-                session: sessionId,
-            })).rejects.toThrow();
-        }, 60000);
-    });
-    // ==========================================================================
-    // Error Cases
-    // ==========================================================================
-    describe('Error Cases', () => {
-        it('should fail with invalid session ID', async () => {
-            await expect(client.run({
-                app: SESSION_TEST_APP,
-                function: 'get_value',
-                input: { key: 'foo' },
-                session: 'sess_invalid_does_not_exist_12345',
-            })).rejects.toThrow();
-        }, 30000);
-    });
-    // ==========================================================================
-    // Performance Tests
-    // ==========================================================================
-    describe('Performance', () => {
-        it('should be faster on warm worker', async () => {
-            // Create session (cold start)
-            const result1 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'perf_test', value: '1' },
-                session: 'new',
-            });
-            expect(result1.status).toBe(TaskStatusCompleted);
-            const sessionId = result1.session_id;
-            // Second call should be fast (warm worker)
-            const start = Date.now();
-            const result2 = await client.run({
-                app: SESSION_TEST_APP,
-                function: 'set_value',
-                input: { key: 'perf_test', value: '2' },
-                session: sessionId,
-            });
-            const elapsed = Date.now() - start;
-            expect(result2.status).toBe(TaskStatusCompleted);
-            // Log for visibility
-            console.log(`Warm worker call took: ${elapsed}ms`);
-            // Should be under 2 seconds for warm worker
-            expect(elapsed).toBeLessThan(2000);
-        }, 120000);
-    });
-});
-// Placeholder test that always runs
-describe('Sessions Integration Test Setup', () => {
-    it('should have API key check', () => {
-        if (!API_KEY) {
-            console.log('⚠️  Skipping sessions integration tests - INFERENCE_API_KEY not set');
-        }
-        expect(true).toBe(true);
-    });
-});

package/dist/stream.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/stream.test.js

@@ -1,363 +0,0 @@
-import { StreamManager } from './http/stream';
-describe('StreamManager', () => {
-    let mockEventSource;
-    beforeEach(() => {
-        mockEventSource = {
-            onmessage: null,
-            onerror: null,
-            close: jest.fn(),
-        };
-    });
-    describe('constructor', () => {
-        it('should create instance with default options', () => {
-            const manager = new StreamManager({
-                createEventSource: async () => mockEventSource,
-            });
-            expect(manager).toBeDefined();
-        });
-    });
-    describe('connect', () => {
-        it('should call createEventSource', async () => {
-            const createEventSource = jest
-                .fn()
-                .mockResolvedValue(mockEventSource);
-            const manager = new StreamManager({ createEventSource });
-            await manager.connect();
-            expect(createEventSource).toHaveBeenCalled();
-        });
-        it('should call onStart when connected', async () => {
-            const onStart = jest.fn();
-            const manager = new StreamManager({
-                createEventSource: async () => mockEventSource,
-                onStart,
-            });
-            await manager.connect();
-            expect(onStart).toHaveBeenCalled();
-        });
-        it('should not call onStart when createEventSource returns null', async () => {
-            const onStart = jest.fn();
-            const manager = new StreamManager({
-                createEventSource: async () => null,
-                onStart,
-            });
-            await manager.connect();
-            expect(onStart).not.toHaveBeenCalled();
-        });
-        it('should parse JSON messages and call onData', async () => {
-            const onData = jest.fn();
-            const manager = new StreamManager({
-                createEventSource: async () => mockEventSource,
-                onData,
-            });
-            await manager.connect();
-            // Simulate receiving a message
-            const testData = { status: 'running', id: 'task-123' };
-            mockEventSource.onmessage?.({ data: JSON.stringify(testData) });
-            expect(onData).toHaveBeenCalledWith(testData);
-        });
-        it('should extract data from partial data wrapper and call onData', async () => {
-            const onData = jest.fn();
-            const manager = new StreamManager({
-                createEventSource: async () => mockEventSource,
-                onData,
-            });
-            await manager.connect();
-            // Simulate receiving a partial data wrapper from server
-            const innerData = { status: 7, id: 'task-123', logs: ['log1'] };
-            const partialWrapper = { data: innerData, fields: ['status', 'logs'] };
-            mockEventSource.onmessage?.({ data: JSON.stringify(partialWrapper) });
-            // onData should receive the extracted inner data, not the wrapper
-            expect(onData).toHaveBeenCalledWith(innerData);
-        });
-        it('should call onPartialData with data and fields for partial updates', async () => {
-            const onData = jest.fn();
-            const onPartialData = jest.fn();
-            const manager = new StreamManager({
-                createEventSource: async () => mockEventSource,
-                onData,
-                onPartialData,
-            });
-            await manager.connect();
-            // Simulate receiving a partial data wrapper
-            const innerData = { status: 7, id: 'task-123' };
-            const fields = ['status'];
-            const partialWrapper = { data: innerData, fields };
-            mockEventSource.onmessage?.({ data: JSON.stringify(partialWrapper) });
-            // When onPartialData is provided, only it is called (not onData)
-            expect(onPartialData).toHaveBeenCalledWith(innerData, fields);
-            expect(onData).not.toHaveBeenCalled();
-        });
-        it('should not call onPartialData for non-partial data', async () => {
-            const onData = jest.fn();
-            const onPartialData = jest.fn();
-            const manager = new StreamManager({
-                createEventSource: async () => mockEventSource,
-                onData,
-                onPartialData,
-            });
-            await manager.connect();
-            // Regular data without partial wrapper
-            const regularData = { status: 9, id: 'task-123' };
-            mockEventSource.onmessage?.({ data: JSON.stringify(regularData) });
-            expect(onPartialData).not.toHaveBeenCalled();
-            expect(onData).toHaveBeenCalledWith(regularData);
-        });
-        it('should call onError for invalid JSON', async () => {
-            const onError = jest.fn();
-            const manager = new StreamManager({
-                createEventSource: async () => mockEventSource,
-                onError,
-            });
-            await manager.connect();
-            mockEventSource.onmessage?.({ data: 'invalid json' });
-            expect(onError).toHaveBeenCalled();
-        });
-    });
-    describe('stop', () => {
-        it('should close the event source', async () => {
-            const onStop = jest.fn();
-            const manager = new StreamManager({
-                createEventSource: async () => mockEventSource,
-                onStop,
-            });
-            await manager.connect();
-            manager.stop();
-            expect(mockEventSource.close).toHaveBeenCalled();
-            expect(onStop).toHaveBeenCalled();
-        });
-        it('should not process messages after stop', async () => {
-            const onData = jest.fn();
-            const manager = new StreamManager({
-                createEventSource: async () => mockEventSource,
-                onData,
-            });
-            await manager.connect();
-            manager.stop();
-            mockEventSource.onmessage?.({ data: '{"status":"running"}' });
-            expect(onData).not.toHaveBeenCalled();
-        });
-    });
-    describe('addEventListener', () => {
-        it('should deliver typed SSE events to registered listeners', async () => {
-            const typedListeners = {};
-            const eventSource = {
-                onmessage: null,
-                onerror: null,
-                close: jest.fn(),
-                addEventListener: (eventName, handler) => {
-                    const listeners = typedListeners[eventName] || new Set();
-                    listeners.add(handler);
-                    typedListeners[eventName] = listeners;
-                },
-            };
-            const manager = new StreamManager({
-                createEventSource: async () => eventSource,
-            });
-            const onChat = jest.fn();
-            manager.addEventListener('chats', onChat);
-            await manager.connect();
-            const payload = { id: 'chat-1', status: 'open' };
-            typedListeners.chats?.forEach((handler) => handler({ data: JSON.stringify(payload) }));
-            expect(onChat).toHaveBeenCalledWith(payload);
-        });
-        it('should unwrap partial wrappers for typed events', async () => {
-            const typedListeners = {};
-            const eventSource = {
-                onmessage: null,
-                onerror: null,
-                close: jest.fn(),
-                addEventListener: (eventName, handler) => {
-                    const listeners = typedListeners[eventName] || new Set();
-                    listeners.add(handler);
-                    typedListeners[eventName] = listeners;
-                },
-            };
-            const manager = new StreamManager({
-                createEventSource: async () => eventSource,
-            });
-            const onMessage = jest.fn();
-            manager.addEventListener('chat_messages', onMessage);
-            await manager.connect();
-            const inner = { id: 'msg-1', order: 1 };
-            typedListeners.chat_messages?.forEach((handler) => handler({
-                data: JSON.stringify({ data: inner, fields: ['order'] }),
-            }));
-            expect(onMessage).toHaveBeenCalledWith(inner);
-        });
-    });
-    describe('reconnection', () => {
-        it('should attempt reconnection on error when autoReconnect is true', async () => {
-            jest.useFakeTimers();
-            const createEventSource = jest
-                .fn()
-                .mockResolvedValue(mockEventSource);
-            const manager = new StreamManager({
-                createEventSource,
-                autoReconnect: true,
-                reconnectDelayMs: 100,
-            });
-            await manager.connect();
-            expect(createEventSource).toHaveBeenCalledTimes(1);
-            // Simulate error
-            mockEventSource.onerror?.({});
-            // Fast-forward past reconnect delay
-            jest.advanceTimersByTime(100);
-            await Promise.resolve(); // Flush promises
-            expect(createEventSource).toHaveBeenCalledTimes(2);
-            jest.useRealTimers();
-        });
-        it('should not reconnect when autoReconnect is false', async () => {
-            const createEventSource = jest
-                .fn()
-                .mockResolvedValue(mockEventSource);
-            const manager = new StreamManager({
-                createEventSource,
-                autoReconnect: false,
-            });
-            await manager.connect();
-            mockEventSource.onerror?.({});
-            // Wait a bit
-            await new Promise((r) => setTimeout(r, 50));
-            expect(createEventSource).toHaveBeenCalledTimes(1);
-        });
-        it('should stop reconnecting after maxReconnects initial failures', async () => {
-            jest.useFakeTimers();
-            const onError = jest.fn();
-            const createEventSource = jest
-                .fn()
-                .mockResolvedValue(mockEventSource);
-            const manager = new StreamManager({
-                createEventSource,
-                autoReconnect: true,
-                maxReconnects: 2,
-                reconnectDelayMs: 100,
-                onError,
-            });
-            await manager.connect();
-            mockEventSource.onerror?.({});
-            jest.advanceTimersByTime(100);
-            await Promise.resolve();
-            expect(createEventSource).toHaveBeenCalledTimes(2);
-            mockEventSource.onerror?.({});
-            jest.advanceTimersByTime(100);
-            await Promise.resolve();
-            expect(createEventSource).toHaveBeenCalledTimes(3);
-            mockEventSource.onerror?.({});
-            jest.advanceTimersByTime(100);
-            await Promise.resolve();
-            expect(createEventSource).toHaveBeenCalledTimes(3);
-            jest.useRealTimers();
-        });
-        it('should call onError and stop when createEventSource throws', async () => {
-            jest.useFakeTimers();
-            const onError = jest.fn();
-            const createEventSource = jest
-                .fn()
-                .mockRejectedValue(new Error('connection refused'));
-            const manager = new StreamManager({
-                createEventSource,
-                autoReconnect: false,
-                onError,
-            });
-            await manager.connect();
-            expect(onError).toHaveBeenCalledWith(expect.objectContaining({ message: 'connection refused' }));
-            jest.useRealTimers();
-        });
-    });
-    describe('stopAfter and clearStopTimeout', () => {
-        it('should stop after the configured delay', async () => {
-            jest.useFakeTimers();
-            const onStop = jest.fn();
-            const manager = new StreamManager({
-                createEventSource: async () => mockEventSource,
-                onStop,
-            });
-            await manager.connect();
-            manager.stopAfter(5000);
-            jest.advanceTimersByTime(5000);
-            expect(mockEventSource.close).toHaveBeenCalled();
-            expect(onStop).toHaveBeenCalled();
-            jest.useRealTimers();
-        });
-        it('should cancel a pending stop when clearStopTimeout is called', async () => {
-            jest.useFakeTimers();
-            const manager = new StreamManager({
-                createEventSource: async () => mockEventSource,
-            });
-            await manager.connect();
-            manager.stopAfter(5000);
-            manager.clearStopTimeout();
-            jest.advanceTimersByTime(5000);
-            expect(mockEventSource.close).not.toHaveBeenCalled();
-            jest.useRealTimers();
-        });
-    });
-    describe('addEventListener lifecycle', () => {
-        it('should register listeners on an existing connection when added after connect', async () => {
-            const typedListeners = {};
-            const eventSource = {
-                onmessage: null,
-                onerror: null,
-                close: jest.fn(),
-                addEventListener: (eventName, handler) => {
-                    const listeners = typedListeners[eventName] || new Set();
-                    listeners.add(handler);
-                    typedListeners[eventName] = listeners;
-                },
-            };
-            const manager = new StreamManager({
-                createEventSource: async () => eventSource,
-            });
-            await manager.connect();
-            const onChat = jest.fn();
-            manager.addEventListener('chats', onChat);
-            const payload = { id: 'chat-2' };
-            typedListeners.chats?.forEach((handler) => handler({ data: JSON.stringify(payload) }));
-            expect(onChat).toHaveBeenCalledWith(payload);
-        });
-        it('should remove a listener when the cleanup function is called', async () => {
-            const typedListeners = {};
-            const eventSource = {
-                onmessage: null,
-                onerror: null,
-                close: jest.fn(),
-                addEventListener: (eventName, handler) => {
-                    const listeners = typedListeners[eventName] || new Set();
-                    listeners.add(handler);
-                    typedListeners[eventName] = listeners;
-                },
-            };
-            const manager = new StreamManager({
-                createEventSource: async () => eventSource,
-            });
-            const onChat = jest.fn();
-            const unsubscribe = manager.addEventListener('chats', onChat);
-            await manager.connect();
-            unsubscribe();
-            typedListeners.chats?.forEach((handler) => handler({ data: '{"id":"chat-3"}' }));
-            expect(onChat).not.toHaveBeenCalled();
-        });
-        it('should call onError when typed event payload is invalid JSON', async () => {
-            const typedListeners = {};
-            const eventSource = {
-                onmessage: null,
-                onerror: null,
-                close: jest.fn(),
-                addEventListener: (eventName, handler) => {
-                    const listeners = typedListeners[eventName] || new Set();
-                    listeners.add(handler);
-                    typedListeners[eventName] = listeners;
-                },
-            };
-            const onError = jest.fn();
-            const manager = new StreamManager({
-                createEventSource: async () => eventSource,
-                onError,
-            });
-            manager.addEventListener('chats', jest.fn());
-            await manager.connect();
-            typedListeners.chats?.forEach((handler) => handler({ data: 'not-json' }));
-            expect(onError).toHaveBeenCalled();
-        });
-    });
-});

package/dist/streamable.integration.test.d.ts

@@ -1,11 +0,0 @@
-/**
- * Integration tests for streamable HTTP client
- *
- * Tests NDJSON streaming against the real API.
- * Run with: INFERENCE_API_KEY=xxx npm run test:integration
- *
- * Note: Format negotiation tests may be skipped if server doesn't support NDJSON yet.
- *
- * @jest-environment node
- */
-export {};