@inferencesh/sdk 0.1.1 → 0.1.3

package/dist/client.js

@@ -4,6 +4,7 @@ exports.inference = exports.Inference = void 0;
 const types_1 = require("./types");
 const stream_1 = require("./stream");
 const eventsource_1 = require("eventsource");
+const errors_1 = require("./errors");
 /**
  * Inference.sh SDK Client
  *
@@ -43,11 +44,45 @@ 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) {
         const url = new URL(`${this.baseUrl}${endpoint}`);

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,17 +60,95 @@ 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');
@@ -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,5 @@
 export { Inference, inference, InferenceConfig, RunOptions, UploadFileOptions } from './client';
 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,7 +14,7 @@ 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;
+exports.RequirementsNotMetException = exports.InferenceError = exports.StreamManager = exports.inference = exports.Inference = void 0;
 // Main client export
 var client_1 = require("./client");
 Object.defineProperty(exports, "Inference", { enumerable: true, get: function () { return client_1.Inference; } });
@@ -22,5 +22,9 @@ Object.defineProperty(exports, "inference", { enumerable: true, get: function ()
 // 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);