@relevanceai/sdk 2.0.1 → 3.0.0-alpha.0

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/region.d.ts

@@ -0,0 +1,5 @@
+export type Region = "bcbe5a" | "d7b62b" | "f1db6c";
+export declare const REGION_US = "bcbe5a";
+export declare const REGION_EU = "d7b62b";
+export declare const REGION_AU = "f1db6c";
+export declare function regionBaseURL(region: Region): string;

package/esm/region.js

@@ -0,0 +1,6 @@
+export const REGION_US = "bcbe5a";
+export const REGION_EU = "d7b62b";
+export const REGION_AU = "f1db6c";
+export function regionBaseURL(region) {
+    return `https://api-${region}.stack.tryrelevance.com`;
+}

package/esm/task.d.ts

@@ -0,0 +1,25 @@
+import { Client } from "./client.js";
+import type { TaskMessage } from "./message.js";
+export type TaskStatus = "not-started" | "idle" | "queued" | "running" | "action" | "complete" | "error";
+export declare abstract class Task<S, E extends Record<string, unknown>> extends EventTarget {
+    #private;
+    readonly subject: S;
+    protected readonly client: Client;
+    private listenController;
+    abstract fetchMessages(fetchOptions?: {
+        from?: Date;
+    }): Promise<TaskMessage[]>;
+    abstract fetchStatus(): Promise<TaskStatus>;
+    constructor(subject: S, id?: string | undefined, client?: Client);
+    get id(): string | undefined;
+    protected setId(id: string, status?: TaskStatus): void;
+    listen(): void;
+    isListening(): boolean;
+    stopListening(): void;
+    addEventListener<K extends keyof E>(type: Extract<K, string>, listener: ((event: CustomEvent<E[K]>) => void) | {
+        handleEvent: (event: CustomEvent<E[K]>) => void;
+    } | null, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof E>(type: Extract<K, string>, listener: ((event: CustomEvent<E[K]>) => void) | {
+        handleEvent: (event: CustomEvent<E[K]>) => void;
+    } | null, options?: boolean | AddEventListenerOptions): void;
+}

package/esm/task.js

@@ -0,0 +1,96 @@
+import { Client } from "./client.js";
+import { TaskErrorEvent, TaskMessageEvent, TaskStartEvent, TaskStatusEvent, TaskUpdateEvent, } from "./events.js";
+import { runInterval } from "./utils.js";
+export class Task extends EventTarget {
+    subject;
+    client;
+    #id;
+    listenController;
+    constructor(subject, id = undefined, client = Client.default()) {
+        super();
+        this.subject = subject;
+        this.client = client;
+        this.#id = id;
+    }
+    get id() {
+        return this.#id;
+    }
+    setId(id, status = "not-started") {
+        if (this.#id) {
+            throw new Error("task id is already set");
+        }
+        // @ts-ignore: allow assignment to readonly in this special case
+        this.#id = id;
+        this.dispatchEvent(new TaskStartEvent(id, status));
+    }
+    listen() {
+        if (this.isListening()) {
+            return;
+        }
+        this.listenController = new AbortController();
+        const signal = this.listenController.signal;
+        let currentStatus = null;
+        const messagesCursor = new Date(0);
+        void runInterval(async () => {
+            // no task, yet
+            if (!this.id) {
+                return;
+            }
+            const [status, messages] = await Promise.all([
+                this.fetchStatus(),
+                this.fetchMessages({
+                    from: messagesCursor,
+                }),
+            ]);
+            if (!this.isListening()) {
+                return;
+            }
+            if (status !== currentStatus) {
+                currentStatus = status;
+                this.dispatchEvent(new TaskStatusEvent(status));
+            }
+            if (messages.length) {
+                for (const message of messages) {
+                    switch (message.type) {
+                        case "agent-error":
+                            this.dispatchEvent(new TaskErrorEvent(message));
+                            break;
+                        case "tool-run":
+                            this.dispatchEvent(new TaskUpdateEvent(message));
+                            break;
+                        case "agent-message":
+                        case "user-message":
+                            this.dispatchEvent(new TaskMessageEvent(message));
+                    }
+                }
+                messagesCursor.setTime(
+                // +1 the api treats after inclusively
+                messages.at(-1).createdAt.getTime() + 1);
+            }
+        }, 15_000, { signal });
+    }
+    isListening() {
+        return this.listenController !== undefined;
+    }
+    stopListening() {
+        this.listenController?.abort();
+        this.listenController = undefined;
+    }
+    addEventListener(type, listener, options) {
+        this.listen();
+        const signal = AbortSignal.any([
+            ...(options && typeof options === "object" && options.signal
+                ? [options.signal]
+                : []),
+            this.listenController.signal,
+        ]);
+        const capture = typeof options === "boolean"
+            ? options
+            : Boolean(options?.capture);
+        const addOptions = Object.assign({}, options, { signal, capture });
+        super.addEventListener(type, listener, addOptions);
+    }
+    removeEventListener(type, listener, options) {
+        super.removeEventListener(type, listener, options);
+    }
+}

package/esm/utils.d.ts

@@ -0,0 +1,8 @@
+export declare function abortPromise(signal: AbortSignal, reject?: boolean): Promise<void>;
+export declare function delay(timeout: number): Promise<void>;
+export declare function runInterval(runner: () => Promise<void> | void, interval: number, { signal, }?: {
+    signal?: AbortSignal;
+    immediate?: boolean;
+}): Promise<void>;
+export declare function cleanPath(path: string, version?: string): string;
+export declare function randomUUID(): Promise<any>;

package/esm/utils.js

@@ -0,0 +1,29 @@
+export function abortPromise(signal, reject) {
+    return new Promise((res, rej) => signal.addEventListener("abort", () => reject ? rej() : res()));
+}
+export function delay(timeout) {
+    return new Promise((done) => setTimeout(done, timeout));
+}
+export async function runInterval(runner, interval, { signal, } = {}) {
+    while (true) {
+        if (signal?.aborted) {
+            break;
+        }
+        await runner();
+        await Promise.race([
+            delay(interval),
+            signal ? abortPromise(signal) : new Promise(() => { }),
+        ]);
+    }
+}
+export function cleanPath(path, version = "latest") {
+    return `/${version}/${path.trim().replace(/^\/+/, "")}`;
+}
+export async function randomUUID() {
+    if (typeof crypto !== "undefined") {
+        return crypto.randomUUID();
+    }
+    // @ts-ignore allow this import for node builds
+    const cryptoModule = await import("node:crypto");
+    return cryptoModule.randomUUID();
+}

package/package.json

@@ -1,38 +1,13 @@
 {
   "name": "@relevanceai/sdk",
-  "version": "2.0.1",
-  "description": "Javascript client for RelevanceAI APIs. Browser, Node.js and typescript support.",
-  "main": "./dist-cjs/index.js",
-  "types": "./dist-types/index.d.ts",
-  "module": "./dist-es/index.js",
-  "files": [
-    "dist-*"
-  ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json && tsc -p tsconfig.es.json && tsc -p tsconfig.types.json",
-    "generate": "ts-node ./src/shared/generate.ts",
-    "test": "jest",
-    "prepare": "npm run build",
-    "sample": "ts-node ./test/sample.test.mjs"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/RelevanceAI/relevance-js-sdk.git"
-  },
-  "author": "",
-  "license": "ISC",
-  "bugs": {
-    "url": "https://github.com/RelevanceAI/relevance-js-sdk/issues"
-  },
-  "homepage": "https://github.com/RelevanceAI/relevance-js-sdk#readme",
-  "devDependencies": {
-    "@types/jest": "^27.0.2",
-    "openapi-typescript": "^4.4.0",
-    "ts-jest": "^27.0.7",
-    "ts-node": "^10.4.0",
-    "typescript": "^4.4.4"
-  },
-  "dependencies": {
-    "cross-fetch": "^3.1.4"
-  }
-}
+  "version": "3.0.0-alpha.0",
+  "license": "MIT",
+  "module": "./esm/mod.js",
+  "exports": {
+    ".": {
+      "import": "./esm/mod.js"
+    }
+  },
+  "scripts": {},
+  "_generatedBy": "dnt@dev"
+}

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2021 Relevance AI
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.

package/README.md

@@ -1,121 +0,0 @@
-# relevance-js-sdk
-Install with npm using:
-```
-npm i @relevanceai/sdk
-```
-## Features
-- Node and Browser support
-- Typescript definitions for almost all [relevanceai.com](https://relevanceai.com/) apis
-- Insert millions of documents with one function call
-- Our SearchBuilder makes searching, filtering, and aggregating your data simple
-# Getting started
-Get started by creating an account in [cloud.relevanceai.com](https://cloud.relevanceai.com) - select the Vector Database onboarding option. Once set up you can fetch your API key and use the below snippet.
-
-```javascript
-import {VecDBClient,QueryBuilder} from "@relevanceai/sdk";
-
-const discovery = new VecDBClient({
-  project: '',
-  api_key: '',
-  endpoint: ''
-});
-const dataset = discovery.dataset('1000-movies');
-
-const movies = [{ title: 'Lord of the Rings: The Fellowship of the Ring', grenre: 'action', budget: 100 }, ...]
-await dataset.insertDocuments(movies, [{ model_name: 'text-embedding-ada-002', field: 'title' }]);
-
-const {results} = await dataset.search(QueryBuilder().vector('title_vector_', { query: 'LOTR', model: 'text-embeddings-ada-002' }));
-```
-## Set up your credentials
-### Option 1 - Use environment variables
-First, set environment variables in your shell before you run your code. 
-
-set RELEVANCE_PROJECT to your project name.
-
-set RELEVANCE_API_KEY to your api key.
-for more information, view the docs here: [Authorization docs](https://discovery.relevanceai.com/reference/api-usage)
-
-Heres a template to copy and paste in for linux environments:
-```bash
-export RELEVANCE_PROJECT=#########
-export RELEVANCE_API_KEY=#########
-```
-The SDK will use these variables when making api calls. You can then initialise your client like this:
-```javascript
-import {VecDBClient} from "@relevanceai/sdk";
-const client = new VecDBClient({});
-```
-### Option 2 - Passing them in code.
-```javascript
-import {VecDBClient} from "@relevanceai/sdk";
-const client = new VecDBClient({
-  project:'########',
-  api_key:'########',
-});
-```
-# Examples
-### You can import builders and type definitions like this
-```javascript
-import {QueryBuilder,VecDBClient,BulkInsertOutput} from "@relevanceai/sdk";
-```
-## Insert millions of items with one function call
-```javascript
-const discovery = new VecDBClient({ ... });
-const dataset = discovery.dataset('tshirts-prod');
- // Here we create some demo data. Replace this with your real data
-const fakeVector = [];
-for (let i = 0; i < 768; i++) fakeVector.push(1);
-const tshirtsData = [];
-for (let i = 0; i < 10000; i++) {
-  tshirtsData.push({_id:`tshirt-${i}1`,color:'red',price:i/1000,'title-fake_vector_':fakeVector});
-  tshirtsData.push({_id:`tshirt-${i}2`,color:'blue',price:i/1000});
-  tshirtsData.push({_id:`tshirt-${i}3`,color:'orange',price:i/1000});
-}
-const res = await dataset.insertDocuments(tshirtsData,{batchSize:10000});
-```
-### insertDocuments will output:
-```javascript
-{"inserted":30000,"failed_documents":[]}
-```
-## Text Search and Vector Search
-```javascript
-const builder = QueryBuilder();
-builder.query('red').text().vector('title-fake_vector_',0.5).minimumRelevance(0.1);
-// .text() searches all fields. alternatively, use .text(field1).text(field2)... to search specific fields
-const searchResults = await dataset.search(builder);
-```
-## Filter and retrieve items
-```javascript
-const filters = QueryBuilder();
-filters.match('color',['blue','red']).range('price',{lessThan:50});
-const filteredItems = await dataset.search(filters);
-```
-### search will output:
-```javascript
-{
-  results: [
-    {
-      color: 'red',
-      price: 0,
-      insert_date_: '2021-11-16T03:14:28.509Z',
-      _id: 'tshirt-01',
-      _relevance: 0
-    }
-    ...
-  ],
-  resultsSize: 10200,
-  aggregations: {},
-  aggregates: {},
-  aggregateStats: {}
-}
-```
-
-
-```
-## Call raw api methods directly
-```javascript
-const discovery = new VecDBClient({ ... });
-const dataset = discovery.dataset('tshirts-prod');
-const {body} = await dataset.apiClient.FastSearch({filters:[{match:{key:'_id',value:`tshirt-01`}}]});
-expect((body.results[0] as any).color).toBe('red')
-```