Merge branch 'main' into stream

Author: mattt

README.md

@@ -403,6 +403,14 @@ const response = await replicate.predictions.list();
 
 ### `replicate.trainings.create`
 
+Use the training API to fine-tune language models
+to make them better at a particular task.
+To see what **language models** currently support fine-tuning,
+check out Replicate's [collection of trainable language models](https://replicate.com/collections/trainable-language-models).
+
+If you're looking to fine-tune **image models**,
+check out Replicate's [guide to fine-tuning image models](https://replicate.com/docs/guides/fine-tune-an-image-model).
+
 ```js
 const response = await replicate.trainings.create(model_owner, model_name, version_id, options);
 ```
@@ -434,6 +442,10 @@ const response = await replicate.trainings.create(model_owner, model_name, versi
 }
 ```
 
+> **Warning**
+> If you try to fine-tune a model that doesn't support training,
+> you'll get a `400 Bad Request` response from the server.
+
 ### `replicate.trainings.get`
 
 ```js

index.d.ts

@@ -2,10 +2,9 @@ declare module 'replicate' {
   type Status = 'starting' | 'processing' | 'succeeded' | 'failed' | 'canceled';
   type WebhookEventType = 'start' | 'output' | 'logs' | 'completed';
 
-  interface Page<T> {
-    previous?: string;
-    next?: string;
-    results: T[];
+  export interface ApiError extends Error {
+    request: Request;
+    response: Response;
   }
 
   export interface Collection {
@@ -63,6 +62,12 @@ declare module 'replicate' {
 
   export type Training = Prediction;
 
+  interface Page<T> {
+    previous?: string;
+    next?: string;
+    results: T[];
+  }
+
   export default class Replicate {
     constructor(options: {
       auth: string;

index.js

@@ -1,7 +1,10 @@
+const ApiError = require('./lib/error');
+
 const collections = require('./lib/collections');
 const models = require('./lib/models');
 const predictions = require('./lib/predictions');
 const trainings = require('./lib/trainings');
+
 const packageJSON = require('./package.json');
 
 /**
@@ -132,7 +135,7 @@ class Replicate {
    * @param {object|Headers} [options.headers] - HTTP headers
    * @param {object} [options.data] - Body parameters
    * @returns {Promise<Response>} - Resolves with the response object
-   * @throws {Error} If the request failed
+   * @throws {ApiError} If the request failed
    */
   async request(route, options) {
     const { auth, baseUrl, userAgent } = this;
@@ -163,14 +166,22 @@ class Replicate {
       });
     }
 
-    const response = await this.fetch(url, {
+    const init = {
       method,
       headers,
       body: data ? JSON.stringify(data) : undefined,
-    });
+    };
+
+    const response = await this.fetch(url, init);
 
     if (!response.ok) {
-      throw new Error(`API request failed: ${response.statusText}`);
+      const request = new Request(url, init);
+      const responseText = await response.text();
+      throw new ApiError(
+        `Request to ${url} failed with status ${response.status} ${response.statusText}: ${responseText}.`,
+        request,
+        response,
+      );
     }
 
     return response;
@@ -187,7 +198,7 @@ class Replicate {
    * @param {Function} endpoint - Function that returns a promise for the next page of results
    * @yields {object[]} Each page of results
    */
-  async *paginate(endpoint) {
+  async * paginate(endpoint) {
     const response = await endpoint();
     yield response.results;
     if (response.next) {

index.test.ts

@@ -181,6 +181,29 @@ describe('Replicate client', () => {
         });
       }).rejects.toThrow('Invalid webhook URL');
     });
+
+    test('Throws an error with details failing response is JSON', async () => {
+      nock(BASE_URL)
+        .post('/predictions')
+        .reply(400, {
+          status: 400,
+          detail: "Invalid input",
+        }, { "Content-Type": "application/json" })
+
+      try {
+        expect.assertions(2);
+
+        await client.predictions.create({
+          version: '5c7d5dc6dd8bf75c1acaa8565735e7986bc5b66206b55cca93cb72c9bf15ccaa',
+          input: {
+            text: null,
+          },
+        });
+      } catch (error) {
+        expect(error.response.status).toBe(400);
+        expect(error.message).toContain("Invalid input")
+      }
+    })
     // Add more tests for error handling, edge cases, etc.
   });
 

lib/error.js

@@ -0,0 +1,21 @@
+/**
+ * A representation of an API error.
+ */
+class ApiError extends Error {
+  /**
+   * Creates a representation of an API error.
+   *
+   * @param {string} message - Error message
+   * @param {Request} request - HTTP request
+   * @param {Response} response - HTTP response
+   * @returns {ApiError} - An instance of ApiError
+   */
+  constructor(message, request, response) {
+    super(message);
+    this.name = 'ApiError';
+    this.request = request;
+    this.response = response;
+  }
+}
+
+module.exports = ApiError;