feat: Initial Project files

Author: asafgardin

dist/Client.d.ts

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

dist/Client.js

@@ -0,0 +1,23 @@
+import { APIClient } from "./Core.js";
+export class AI21 extends APIClient {
+    constructor(apiKey) {
+        super({
+            baseURL: 'https://api.ai21.com/studio/v1',
+            timeout: 60000,
+            apiKey,
+            options: {}
+        });
+    }
+    // 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 }
+        });
+    }
+}

dist/Core.d.ts

@@ -0,0 +1,88 @@
+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 = {
+    response: Response;
+    options: FinalRequestOptions;
+    controller: AbortController;
+};
+export type RequestOptions<Req = unknown | Record<string, unknown> | Readable | BlobLike | ArrayBufferView | ArrayBuffer> = {
+    method?: HTTPMethod;
+    path?: string;
+    query?: Req | undefined;
+    body?: Req | null | undefined;
+    headers?: Headers | undefined;
+    maxRetries?: number;
+    stream?: boolean | undefined;
+    timeout?: number;
+};
+export type FinalRequestOptions = RequestOptions & {
+    method: HTTPMethod;
+    path: string;
+};
+export declare const createResponseHeaders: (headers: Awaited<ReturnType<any>>["headers"]) => Record<string, string>;
+type ClientOptions = {
+    apiKey?: string;
+    organization?: string | null;
+    project?: string | null;
+    baseURL?: string;
+    maxRetries?: number;
+    timeout?: number;
+    defaultQuery?: DefaultQuery;
+    defaultHeaders?: Headers;
+    dangerouslyAllowBrowser?: boolean;
+};
+type DefaultQuery = Record<string, unknown>;
+type PromiseOrValue<T> = T | Promise<T>;
+export declare class APIPromise<T> extends Promise<T> {
+    private responsePromise;
+    private parseResponse;
+    constructor(responsePromise: Promise<APIResponseProps>, parseResponse?: (props: APIResponseProps) => Promise<T>);
+    /**
+     * Gets the raw Response instance
+     */
+    asResponse(): Promise<Response>;
+    /**
+     * Gets both the parsed response data and the raw Response instance
+     */
+    withResponse(): Promise<{
+        data: T;
+        response: Response;
+    }>;
+    private parse;
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null): Promise<T>;
+}
+export declare abstract class APIClient {
+    protected options: ClientOptions;
+    protected apiKey: string;
+    protected baseURL: string;
+    protected maxRetries: number;
+    protected timeout: number;
+    constructor({ baseURL, maxRetries, timeout, // 10 minutes
+    apiKey, options, }: {
+        baseURL: string;
+        maxRetries?: number | undefined;
+        timeout: number | undefined;
+        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>;
+    private getUserAgent;
+    protected defaultHeaders(opts: FinalRequestOptions): Headers;
+    protected authHeaders(opts: FinalRequestOptions): Headers;
+    protected defaultQuery(): DefaultQuery | undefined;
+    protected stringifyQuery(query: Record<string, unknown>): string;
+    private makeRequest;
+    private performRequest;
+    protected static isRunningInBrowser(): boolean;
+}
+export declare const readEnv: (env: string) => string | undefined;
+export {};

dist/Core.js

@@ -0,0 +1,151 @@
+import { AI21Error } from "./errors.js";
+import { VERSION } from "./version.js";
+import fetch from 'node-fetch';
+export const createResponseHeaders = (headers) => {
+    return new Proxy(Object.fromEntries(
+    // @ts-ignore
+    headers.entries()), {
+        get(target, name) {
+            const key = name.toString();
+            return target[key.toLowerCase()] || target[key];
+        },
+    });
+};
+const validatePositiveInteger = (name, n) => {
+    if (typeof n !== 'number' || !Number.isInteger(n)) {
+        throw new AI21Error(`${name} must be an integer`);
+    }
+    if (n < 0) {
+        throw new AI21Error(`${name} must be a positive integer`);
+    }
+    return n;
+};
+async function defaultParseResponse({ response }) {
+    const contentType = response.headers.get('content-type');
+    if (contentType?.includes('application/json')) {
+        return response.json();
+    }
+    return response.text();
+}
+export class APIPromise extends Promise {
+    constructor(responsePromise, parseResponse = defaultParseResponse) {
+        super((resolve) => resolve(null));
+        this.responsePromise = responsePromise;
+        this.parseResponse = parseResponse;
+    }
+    /**
+     * Gets the raw Response instance
+     */
+    asResponse() {
+        return this.responsePromise.then((p) => p.response);
+    }
+    /**
+     * Gets both the parsed response data and the raw Response instance
+     */
+    async withResponse() {
+        const [data, response] = await Promise.all([this.parse(), this.asResponse()]);
+        return { data, response };
+    }
+    parse() {
+        return this.responsePromise.then(this.parseResponse);
+    }
+    then(onfulfilled, onrejected) {
+        return this.parse().then(onfulfilled, onrejected);
+    }
+    catch(onrejected) {
+        return this.parse().catch(onrejected);
+    }
+    finally(onfinally) {
+        return this.parse().finally(onfinally);
+    }
+}
+export class APIClient {
+    constructor({ baseURL, maxRetries = 2, timeout = 600000, // 10 minutes
+    // fetch: overridenFetch,
+    apiKey, options, }) {
+        this.baseURL = baseURL;
+        this.maxRetries = validatePositiveInteger('maxRetries', maxRetries);
+        this.timeout = validatePositiveInteger('timeout', timeout);
+        this.apiKey = apiKey;
+        this.options = options;
+    }
+    get(path, opts) {
+        return this.makeRequest('get', path, opts);
+    }
+    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}`;
+    }
+    defaultHeaders(opts) {
+        return {
+            Accept: 'application/json',
+            'Content-Type': 'application/json',
+            'User-Agent': this.getUserAgent(),
+            //   ...getPlatformHeaders(),
+            ...this.authHeaders(opts),
+        };
+    }
+    authHeaders(opts) {
+        return {};
+    }
+    defaultQuery() {
+        return this.options.defaultQuery;
+    }
+    stringifyQuery(query) {
+        const params = new URLSearchParams();
+        for (const [key, value] of Object.entries(query)) {
+            if (value !== undefined && value !== null) {
+                params.append(key, String(value));
+            }
+        }
+        return params.toString();
+    }
+    makeRequest(method, path, opts) {
+        const options = {
+            method,
+            path,
+            ...opts
+        };
+        return new APIPromise(this.performRequest(options));
+    }
+    async performRequest(options) {
+        const controller = new AbortController();
+        const url = `${this.baseURL}${options.path}`;
+        const headers = {
+            ...this.defaultHeaders(options),
+            ...options.headers,
+        };
+        const response = await fetch(url, {
+            method: options.method,
+            headers: headers,
+            signal: controller.signal, // Type cast to avoid AbortSignal compatibility issue
+            body: options.body ? JSON.stringify(options.body) : undefined
+        });
+        if (!response.ok) {
+            throw new AI21Error(`Request failed with status ${response.status}`);
+        }
+        return { response, options, controller };
+    }
+    static isRunningInBrowser() {
+        return (typeof window !== 'undefined' &&
+            typeof window.document !== 'undefined' &&
+            typeof fetch === 'function');
+    }
+}
+export const readEnv = (env) => {
+    if (typeof process !== 'undefined' && process.env) {
+        return process.env[env]?.trim() ?? undefined;
+    }
+    return undefined;
+};

dist/errors.d.ts

@@ -0,0 +1,2 @@
+export declare class AI21Error extends Error {
+}

dist/errors.js

@@ -0,0 +1,2 @@
+export class AI21Error extends Error {
+}

dist/index.d.ts

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

dist/index.js

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

dist/version.d.ts

@@ -0,0 +1 @@
+export declare const VERSION = "0.0.1";

dist/version.js

@@ -0,0 +1 @@
+export const VERSION = '0.0.1';