feat: Support streaming

Author: asafgardin

dist/Client.d.ts

@@ -1,11 +1,7 @@
-import { APIClient, FinalRequestOptions, Headers } from "./Core.js";
-export declare class AI21 extends APIClient {
+import * as Core from "./Core";
+import { Chat } from "./resources/chat";
+export declare class AI21 extends Core.APIClient {
     constructor(apiKey: string);
-    protected authHeaders(opts: FinalRequestOptions): Headers;
-    createChatCompletion(model: string, messages: Array<{
-        role: string;
-        content: string;
-    }>): Promise<{
-        completion: string;
-    }>;
+    protected authHeaders(opts: Core.FinalRequestOptions): Core.Headers;
+    chat: Chat;
 }

dist/Client.js

@@ -1,23 +1,45 @@
-import { APIClient } from "./Core.js";
-export class AI21 extends APIClient {
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI21 = void 0;
+const Core = __importStar(require("./Core"));
+const chat_1 = require("./resources/chat");
+class AI21 extends Core.APIClient {
     constructor(apiKey) {
         super({
             baseURL: 'https://api.ai21.com/studio/v1',
             timeout: 60000,
             apiKey,
             options: {}
         });
+        this.chat = new chat_1.Chat(this);
     }
-    // Override auth headers to include API key
     authHeaders(opts) {
         return {
             'Authorization': `Bearer ${this.apiKey}`
         };
     }
-    // Create a method for chat completions
-    async createChatCompletion(model, messages) {
-        return this.post('/chat/completions', {
-            body: { model, messages }
-        });
-    }
 }
+exports.AI21 = AI21;

dist/Core.d.ts

@@ -1,14 +1,15 @@
+/// <reference types="node" />
 import { BlobLike } from "formdata-node";
 import { Readable } from "stream";
 import { Response } from "node-fetch";
-export type Headers = Record<string, string | null | undefined>;
-type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
-type APIResponseProps = {
+export declare type Headers = Record<string, string | null | undefined>;
+declare type HTTPMethod = 'get' | 'post' | 'put' | 'patch' | 'delete';
+declare type APIResponseProps = {
     response: Response;
     options: FinalRequestOptions;
     controller: AbortController;
 };
-export type RequestOptions<Req = unknown | Record<string, unknown> | Readable | BlobLike | ArrayBufferView | ArrayBuffer> = {
+export declare type RequestOptions<Req = unknown | Record<string, unknown> | Readable | BlobLike | ArrayBufferView | ArrayBuffer> = {
     method?: HTTPMethod;
     path?: string;
     query?: Req | undefined;
@@ -18,12 +19,12 @@ export type RequestOptions<Req = unknown | Record<string, unknown> | Readable |
     stream?: boolean | undefined;
     timeout?: number;
 };
-export type FinalRequestOptions = RequestOptions & {
+export declare type FinalRequestOptions = RequestOptions & {
     method: HTTPMethod;
     path: string;
 };
-export declare const createResponseHeaders: (headers: Awaited<ReturnType<any>>["headers"]) => Record<string, string>;
-type ClientOptions = {
+export declare const createResponseHeaders: (headers: Awaited<ReturnType<any>>['headers']) => Record<string, string>;
+declare type ClientOptions = {
     apiKey?: string;
     organization?: string | null;
     project?: string | null;
@@ -34,8 +35,8 @@ type ClientOptions = {
     defaultHeaders?: Headers;
     dangerouslyAllowBrowser?: boolean;
 };
-type DefaultQuery = Record<string, unknown>;
-type PromiseOrValue<T> = T | Promise<T>;
+declare type DefaultQuery = Record<string, unknown>;
+declare type PromiseOrValue<T> = T | Promise<T>;
 export declare class APIPromise<T> extends Promise<T> {
     private responsePromise;
     private parseResponse;
@@ -70,11 +71,10 @@ export declare abstract class APIClient {
         apiKey: string;
         options: ClientOptions;
     });
-    protected get<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp>;
-    protected post<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp>;
-    protected patch<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp>;
-    protected put<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp>;
-    protected delete<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp>;
+    get<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp>;
+    post<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp>;
+    put<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp>;
+    delete<Req, Rsp>(path: string, opts?: PromiseOrValue<RequestOptions<Req>>): APIPromise<Rsp>;
     private getUserAgent;
     protected defaultHeaders(opts: FinalRequestOptions): Headers;
     protected authHeaders(opts: FinalRequestOptions): Headers;

dist/Core.js

@@ -1,7 +1,14 @@
-import { AI21Error } from "./errors.js";
-import { VERSION } from "./version.js";
-import fetch from 'node-fetch';
-export const createResponseHeaders = (headers) => {
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readEnv = exports.APIClient = exports.APIPromise = exports.createResponseHeaders = void 0;
+const errors_js_1 = require("./errors.js");
+const version_js_1 = require("./version.js");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const Streaming_1 = require("./Streaming");
+const createResponseHeaders = (headers) => {
     return new Proxy(Object.fromEntries(
     // @ts-ignore
     headers.entries()), {
@@ -11,23 +18,30 @@ export const createResponseHeaders = (headers) => {
         },
     });
 };
+exports.createResponseHeaders = createResponseHeaders;
 const validatePositiveInteger = (name, n) => {
     if (typeof n !== 'number' || !Number.isInteger(n)) {
-        throw new AI21Error(`${name} must be an integer`);
+        throw new errors_js_1.AI21Error(`${name} must be an integer`);
     }
     if (n < 0) {
-        throw new AI21Error(`${name} must be a positive integer`);
+        throw new errors_js_1.AI21Error(`${name} must be a positive integer`);
     }
     return n;
 };
-async function defaultParseResponse({ response }) {
+async function defaultParseResponse({ response, options }) {
+    if (options.stream) {
+        if (!response.body) {
+            throw new errors_js_1.AI21Error('Response body is null');
+        }
+        return new Streaming_1.Stream(response);
+    }
     const contentType = response.headers.get('content-type');
     if (contentType?.includes('application/json')) {
         return response.json();
     }
     return response.text();
 }
-export class APIPromise extends Promise {
+class APIPromise extends Promise {
     constructor(responsePromise, parseResponse = defaultParseResponse) {
         super((resolve) => resolve(null));
         this.responsePromise = responsePromise;
@@ -59,7 +73,8 @@ export class APIPromise extends Promise {
         return this.parse().finally(onfinally);
     }
 }
-export class APIClient {
+exports.APIPromise = APIPromise;
+class APIClient {
     constructor({ baseURL, maxRetries = 2, timeout = 600000, // 10 minutes
     // fetch: overridenFetch,
     apiKey, options, }) {
@@ -75,17 +90,14 @@ export class APIClient {
     post(path, opts) {
         return this.makeRequest('post', path, opts);
     }
-    patch(path, opts) {
-        return this.makeRequest('patch', path, opts);
-    }
     put(path, opts) {
         return this.makeRequest('put', path, opts);
     }
     delete(path, opts) {
         return this.makeRequest('delete', path, opts);
     }
     getUserAgent() {
-        return `${this.constructor.name}/JS ${VERSION}`;
+        return `${this.constructor.name}/JS ${version_js_1.VERSION}`;
     }
     defaultHeaders(opts) {
         return {
@@ -126,26 +138,28 @@ export class APIClient {
             ...this.defaultHeaders(options),
             ...options.headers,
         };
-        const response = await fetch(url, {
+        const response = await (0, node_fetch_1.default)(url, {
             method: options.method,
             headers: headers,
-            signal: controller.signal, // Type cast to avoid AbortSignal compatibility issue
+            signal: controller.signal,
             body: options.body ? JSON.stringify(options.body) : undefined
         });
         if (!response.ok) {
-            throw new AI21Error(`Request failed with status ${response.status}`);
+            throw new errors_js_1.AI21Error(`Request failed with status ${response.status}`);
         }
         return { response, options, controller };
     }
     static isRunningInBrowser() {
         return (typeof window !== 'undefined' &&
             typeof window.document !== 'undefined' &&
-            typeof fetch === 'function');
+            typeof node_fetch_1.default === 'function');
     }
 }
-export const readEnv = (env) => {
+exports.APIClient = APIClient;
+const readEnv = (env) => {
     if (typeof process !== 'undefined' && process.env) {
         return process.env[env]?.trim() ?? undefined;
     }
     return undefined;
 };
+exports.readEnv = readEnv;

dist/errors.js

@@ -1,2 +1,6 @@
-export class AI21Error extends Error {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI21Error = void 0;
+class AI21Error extends Error {
 }
+exports.AI21Error = AI21Error;

dist/index.d.ts

@@ -1 +1,2 @@
-export { AI21 } from './Client.js';
+export { AI21 } from './Client';
+export { RequestOptions } from './Core';

dist/index.js

@@ -1 +1,5 @@
-export { AI21 } from './Client.js';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AI21 = void 0;
+var Client_1 = require("./Client");
+Object.defineProperty(exports, "AI21", { enumerable: true, get: function () { return Client_1.AI21; } });

dist/version.js

@@ -1 +1,4 @@
-export const VERSION = '0.0.1';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+exports.VERSION = '0.0.1';