@inferencesh/sdk 0.4.21 → 0.4.23

package/dist/api/tasks.d.ts

@@ -0,0 +1,68 @@
+import { HttpClient } from '../http/client';
+import { TaskDTO as Task, ApiAppRunRequest, CreateTaskRequest, CursorListRequest, CursorListResponse } from '../types';
+export interface RunOptions {
+    /** Callback for real-time status updates */
+    onUpdate?: (update: Task) => void;
+    /** Callback for partial updates with list of changed fields */
+    onPartialUpdate?: (update: Task, fields: string[]) => void;
+    /** Wait for task completion (default: true) */
+    wait?: boolean;
+    /** Auto-reconnect on connection loss (default: true) */
+    autoReconnect?: boolean;
+    /** Maximum reconnection attempts (default: 5) */
+    maxReconnects?: number;
+    /** Delay between reconnection attempts in ms (default: 1000) */
+    reconnectDelayMs?: number;
+}
+/**
+ * Tasks API
+ */
+export declare class TasksAPI {
+    private readonly http;
+    constructor(http: HttpClient);
+    /**
+     * List tasks with cursor-based pagination
+     */
+    list(params?: Partial<CursorListRequest>): Promise<CursorListResponse<Task>>;
+    /**
+     * List featured tasks with cursor-based pagination
+     */
+    listFeatured(params?: Partial<CursorListRequest>): Promise<CursorListResponse<Task>>;
+    /**
+     * Get a task by ID
+     */
+    get(taskId: string): Promise<Task>;
+    /**
+     * Create a task directly
+     * Accepts either simple format { app: string; input: unknown } or full CreateTaskRequest
+     */
+    create(data: CreateTaskRequest | {
+        app: string;
+        input: unknown;
+    }): Promise<Task>;
+    /**
+     * Delete a task
+     */
+    delete(taskId: string): Promise<void>;
+    /**
+     * Cancel a running task
+     */
+    cancel(taskId: string): Promise<void>;
+    /**
+     * Create an EventSource for streaming task updates
+     */
+    stream(taskId: string): Promise<import("eventsource").EventSource | null>;
+    /**
+     * Run a task and optionally wait for completion
+     */
+    run(params: ApiAppRunRequest, processedInput: unknown, options?: RunOptions): Promise<Task>;
+    /**
+     * Update task visibility
+     */
+    updateVisibility(taskId: string, visibility: string): Promise<Task>;
+    /**
+     * Feature/unfeature a task
+     */
+    feature(taskId: string, featured: boolean): Promise<Task>;
+}
+export declare function createTasksAPI(http: HttpClient): TasksAPI;

package/dist/api/tasks.js

@@ -0,0 +1,147 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TasksAPI = void 0;
+exports.createTasksAPI = createTasksAPI;
+const stream_1 = require("../http/stream");
+const types_1 = require("../types");
+function stripTask(task) {
+    return {
+        ...task,
+        id: task.id,
+        created_at: task.created_at,
+        updated_at: task.updated_at,
+        input: task.input,
+        output: task.output,
+        logs: task.logs,
+        status: task.status,
+    };
+}
+/**
+ * Tasks API
+ */
+class TasksAPI {
+    constructor(http) {
+        this.http = http;
+    }
+    /**
+     * List tasks with cursor-based pagination
+     */
+    async list(params) {
+        return this.http.request('post', '/tasks/list', { data: params });
+    }
+    /**
+     * List featured tasks with cursor-based pagination
+     */
+    async listFeatured(params) {
+        return this.http.request('post', '/tasks/featured/list', { data: params });
+    }
+    /**
+     * Get a task by ID
+     */
+    async get(taskId) {
+        return this.http.request('get', `/tasks/${taskId}`);
+    }
+    /**
+     * Create a task directly
+     * Accepts either simple format { app: string; input: unknown } or full CreateTaskRequest
+     */
+    async create(data) {
+        return this.http.request('post', '/tasks', { data });
+    }
+    /**
+     * Delete a task
+     */
+    async delete(taskId) {
+        return this.http.request('delete', `/tasks/${taskId}`);
+    }
+    /**
+     * Cancel a running task
+     */
+    async cancel(taskId) {
+        return this.http.request('post', `/tasks/${taskId}/cancel`);
+    }
+    /**
+     * Create an EventSource for streaming task updates
+     */
+    stream(taskId) {
+        return this.http.createEventSource(`/tasks/${taskId}/stream`);
+    }
+    /**
+     * Run a task and optionally wait for completion
+     */
+    async run(params, processedInput, options = {}) {
+        const { onUpdate, onPartialUpdate, wait = true, autoReconnect = true, maxReconnects = 5, reconnectDelayMs = 1000, } = options;
+        const task = await this.http.request('post', '/apps/run', {
+            data: {
+                ...params,
+                input: processedInput,
+            },
+        });
+        // Return immediately if not waiting
+        if (!wait) {
+            return stripTask(task);
+        }
+        // Wait for completion with optional updates
+        return new Promise((resolve, reject) => {
+            const streamManager = new stream_1.StreamManager({
+                createEventSource: async () => this.http.createEventSource(`/tasks/${task.id}/stream`),
+                autoReconnect,
+                maxReconnects,
+                reconnectDelayMs,
+                onData: (data) => {
+                    const stripped = stripTask(data);
+                    onUpdate?.(stripped);
+                    if (data.status === types_1.TaskStatusCompleted) {
+                        streamManager.stop();
+                        resolve(stripped);
+                    }
+                    else if (data.status === types_1.TaskStatusFailed) {
+                        streamManager.stop();
+                        reject(new Error(data.error || 'task failed'));
+                    }
+                    else if (data.status === types_1.TaskStatusCancelled) {
+                        streamManager.stop();
+                        reject(new Error('task cancelled'));
+                    }
+                },
+                onPartialData: (data, fields) => {
+                    const stripped = stripTask(data);
+                    onPartialUpdate?.(stripped, fields);
+                    if (data.status === types_1.TaskStatusCompleted) {
+                        streamManager.stop();
+                        resolve(stripped);
+                    }
+                    else if (data.status === types_1.TaskStatusFailed) {
+                        streamManager.stop();
+                        reject(new Error(data.error || 'task failed'));
+                    }
+                    else if (data.status === types_1.TaskStatusCancelled) {
+                        streamManager.stop();
+                        reject(new Error('task cancelled'));
+                    }
+                },
+                onError: (error) => {
+                    reject(error);
+                    streamManager.stop();
+                },
+            });
+            streamManager.connect();
+        });
+    }
+    /**
+     * Update task visibility
+     */
+    async updateVisibility(taskId, visibility) {
+        return this.http.request('put', `/tasks/${taskId}/visibility`, { data: { visibility } });
+    }
+    /**
+     * Feature/unfeature a task
+     */
+    async feature(taskId, featured) {
+        return this.http.request('put', `/tasks/${taskId}/feature`, { data: { featured } });
+    }
+}
+exports.TasksAPI = TasksAPI;
+function createTasksAPI(http) {
+    return new TasksAPI(http);
+}

package/dist/client.test.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const client_1 = require("./client");
-const errors_1 = require("./errors");
+const index_1 = require("./index");
+const errors_1 = require("./http/errors");
 // Mock fetch globally
 const mockFetch = jest.fn();
 global.fetch = mockFetch;
@@ -11,19 +11,19 @@ describe('Inference', () => {
     });
     describe('constructor', () => {
         it('should create an instance with valid config', () => {
-            const client = new client_1.Inference({ apiKey: 'test-api-key' });
-            expect(client).toBeInstanceOf(client_1.Inference);
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            expect(client).toBeInstanceOf(index_1.Inference);
         });
         it('should throw error when neither apiKey nor proxyUrl is provided', () => {
-            expect(() => new client_1.Inference({ apiKey: '' })).toThrow('Either apiKey or proxyUrl is required');
-            expect(() => new client_1.Inference({})).toThrow('Either apiKey or proxyUrl is required');
+            expect(() => new index_1.Inference({ apiKey: '' })).toThrow('Either apiKey, getToken, or proxyUrl is required');
+            expect(() => new index_1.Inference({})).toThrow('Either apiKey, getToken, or proxyUrl is required');
         });
         it('should use default baseUrl when not provided', () => {
-            const client = new client_1.Inference({ apiKey: 'test-api-key' });
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
             expect(client).toBeDefined();
         });
         it('should accept custom baseUrl', () => {
-            const client = new client_1.Inference({
+            const client = new index_1.Inference({
                 apiKey: 'test-api-key',
                 baseUrl: 'https://custom-api.example.com',
             });
@@ -47,7 +47,7 @@ describe('Inference', () => {
                 text: () => Promise.resolve(JSON.stringify(responseData)),
                 json: () => Promise.resolve(responseData),
             });
-            const client = new client_1.Inference({ apiKey: 'test-api-key' });
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
             // Use input that won't trigger base64 detection (contains spaces/special chars)
             const result = await client.run({ app: 'test-app', input: { message: 'hello world!' } }, { wait: false });
             expect(result.id).toBe('task-123');
@@ -67,7 +67,7 @@ describe('Inference', () => {
                 text: () => Promise.resolve(JSON.stringify(responseData)),
                 json: () => Promise.resolve(responseData),
             });
-            const client = new client_1.Inference({ apiKey: 'test-api-key' });
+            const client = new index_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 () => {
@@ -92,7 +92,7 @@ describe('Inference', () => {
                 text: () => Promise.resolve(JSON.stringify(responseData)),
                 json: () => Promise.resolve(responseData),
             });
-            const client = new client_1.Inference({ apiKey: 'test-api-key' });
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
             try {
                 await client.run({ app: 'test-app', input: { message: 'test!' } }, { wait: false });
                 fail('Expected RequirementsNotMetException to be thrown');
@@ -128,7 +128,7 @@ describe('Inference', () => {
                 text: () => Promise.resolve(JSON.stringify(responseData)),
                 json: () => Promise.resolve(responseData),
             });
-            const client = new client_1.Inference({ apiKey: 'test-api-key' });
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
             try {
                 await client.run({ app: 'test-app', input: {} }, { wait: false });
                 fail('Expected RequirementsNotMetException to be thrown');
@@ -150,18 +150,143 @@ describe('Inference', () => {
                 text: () => Promise.resolve(JSON.stringify(responseData)),
                 json: () => Promise.resolve(responseData),
             });
-            const client = new client_1.Inference({ apiKey: 'test-api-key' });
+            const client = new index_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('lowercase factory', () => {
         it('should export lowercase inference factory', () => {
-            expect(typeof client_1.inference).toBe('function');
+            expect(typeof index_1.inference).toBe('function');
         });
         it('should work with lowercase inference factory', () => {
-            const client = (0, client_1.inference)({ apiKey: 'test-api-key' });
-            expect(client).toBeInstanceOf(client_1.Inference);
+            const client = (0, index_1.inference)({ apiKey: 'test-api-key' });
+            expect(client).toBeInstanceOf(index_1.Inference);
+        });
+    });
+});
+describe('namespaced APIs', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    describe('client.tasks', () => {
+        it('should have tasks namespace', () => {
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            expect(client.tasks).toBeDefined();
+            expect(typeof client.tasks.run).toBe('function');
+            expect(typeof client.tasks.get).toBe('function');
+            expect(typeof client.tasks.cancel).toBe('function');
+            expect(typeof client.tasks.list).toBe('function');
+            expect(typeof client.tasks.create).toBe('function');
+        });
+        it('should create task via tasks.create()', async () => {
+            const mockTask = {
+                id: 'task-123',
+                status: 1,
+                created_at: new Date().toISOString(),
+                updated_at: new Date().toISOString(),
+                input: { message: 'hello world' },
+            };
+            const responseData = { success: true, data: mockTask };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(responseData)),
+                json: () => Promise.resolve(responseData),
+            });
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            const result = await client.tasks.create({
+                app_id: 'test-app',
+                input: { message: 'hello world!' },
+            });
+            expect(result.id).toBe('task-123');
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/tasks'), expect.objectContaining({ method: 'POST' }));
+        });
+        it('should get task via tasks.get()', async () => {
+            const mockTask = { id: 'task-123', status: 7 };
+            const responseData = { success: true, data: mockTask };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(responseData)),
+                json: () => Promise.resolve(responseData),
+            });
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            const result = await client.tasks.get('task-123');
+            expect(result.id).toBe('task-123');
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/tasks/task-123'), expect.objectContaining({ method: 'GET' }));
+        });
+        it('should cancel task via tasks.cancel()', async () => {
+            const responseData = { success: true, data: null };
+            mockFetch.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                text: () => Promise.resolve(JSON.stringify(responseData)),
+                json: () => Promise.resolve(responseData),
+            });
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            await client.tasks.cancel('task-123');
+            expect(mockFetch).toHaveBeenCalledWith(expect.stringContaining('/tasks/task-123/cancel'), expect.objectContaining({ method: 'POST' }));
+        });
+    });
+    describe('client.files', () => {
+        it('should have files namespace', () => {
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            expect(client.files).toBeDefined();
+            expect(typeof client.files.upload).toBe('function');
+            expect(typeof client.files.list).toBe('function');
+            expect(typeof client.files.get).toBe('function');
+            expect(typeof client.files.delete).toBe('function');
+        });
+    });
+    describe('client.agents', () => {
+        it('should have agents namespace', () => {
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            expect(client.agents).toBeDefined();
+            expect(typeof client.agents.list).toBe('function');
+            expect(typeof client.agents.get).toBe('function');
+            expect(typeof client.agents.create).toBe('function');
+        });
+    });
+    describe('client.apps', () => {
+        it('should have apps namespace', () => {
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            expect(client.apps).toBeDefined();
+            expect(typeof client.apps.list).toBe('function');
+            expect(typeof client.apps.get).toBe('function');
+            expect(typeof client.apps.getByName).toBe('function');
+        });
+    });
+    describe('client.chats', () => {
+        it('should have chats namespace', () => {
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            expect(client.chats).toBeDefined();
+            expect(typeof client.chats.list).toBe('function');
+            expect(typeof client.chats.get).toBe('function');
+        });
+    });
+    describe('client.flows', () => {
+        it('should have flows namespace', () => {
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            expect(client.flows).toBeDefined();
+            expect(typeof client.flows.list).toBe('function');
+            expect(typeof client.flows.get).toBe('function');
+        });
+    });
+    describe('client.flowRuns', () => {
+        it('should have flowRuns namespace', () => {
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            expect(client.flowRuns).toBeDefined();
+            expect(typeof client.flowRuns.list).toBe('function');
+            expect(typeof client.flowRuns.get).toBe('function');
+        });
+    });
+    describe('client.engines', () => {
+        it('should have engines namespace', () => {
+            const client = new index_1.Inference({ apiKey: 'test-api-key' });
+            expect(client.engines).toBeDefined();
+            expect(typeof client.engines.list).toBe('function');
+            expect(typeof client.engines.get).toBe('function');
         });
     });
 });
@@ -184,7 +309,7 @@ describe('uploadFile', () => {
             json: () => Promise.resolve(responseData),
         })
             .mockResolvedValueOnce({ ok: true });
-        const client = new client_1.Inference({ apiKey: 'test-api-key' });
+        const client = new index_1.Inference({ apiKey: 'test-api-key' });
         // Use valid base64 that won't be mistaken for regular text
         const result = await client.uploadFile('SGVsbG8gV29ybGQh', {
             filename: 'test.txt',
@@ -206,7 +331,7 @@ describe('uploadFile', () => {
             text: () => Promise.resolve(JSON.stringify(responseData)),
             json: () => Promise.resolve(responseData),
         });
-        const client = new client_1.Inference({ apiKey: 'test-api-key' });
+        const client = new index_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/http/client.d.ts

@@ -0,0 +1,56 @@
+import { EventSource } from 'eventsource';
+export interface HttpClientConfig {
+    /** Your inference.sh API key (required unless using proxyUrl) */
+    apiKey?: string;
+    /** Custom API base URL (defaults to https://api.inference.sh) */
+    baseUrl?: string;
+    /**
+     * Proxy URL for frontend apps.
+     * When set, requests are routed through your proxy server to protect API keys.
+     */
+    proxyUrl?: string;
+    /** Dynamic token getter (alternative to apiKey) */
+    getToken?: () => string | null | undefined;
+    /** Dynamic headers */
+    headers?: Record<string, string | (() => string | undefined)>;
+    /** Request credentials mode */
+    credentials?: RequestCredentials;
+}
+/**
+ * Low-level HTTP client for inference.sh API
+ *
+ * This client handles authentication, proxy mode, and error handling.
+ * It's designed to be extended by higher-level API modules.
+ */
+export declare class HttpClient {
+    private readonly apiKey;
+    private readonly baseUrl;
+    private readonly proxyUrl;
+    private readonly getToken;
+    private readonly customHeaders;
+    private readonly credentials;
+    constructor(config: HttpClientConfig);
+    /** Get the base URL */
+    getBaseUrl(): string;
+    /** Check if in proxy mode */
+    isProxyMode(): boolean;
+    /** Resolve dynamic headers */
+    private resolveHeaders;
+    /** Get authorization token */
+    private getAuthToken;
+    /**
+     * Make an HTTP request to the API
+     */
+    request<T, P extends object = Record<string, unknown>>(method: 'get' | 'post' | 'put' | 'delete', endpoint: string, options?: {
+        params?: P;
+        data?: unknown;
+    }): Promise<T>;
+    /**
+     * Create an EventSource for SSE streaming
+     */
+    createEventSource(endpoint: string): Promise<EventSource | null>;
+}
+/**
+ * Create an HTTP client instance
+ */
+export declare function createHttpClient(config: HttpClientConfig): HttpClient;