@relevanceai/sdk 3.0.0-alpha.4 → 3.0.0-alpha.6

package/esm/tool.js

@@ -0,0 +1,27 @@
+export class Tool {
+    #config;
+    constructor(config) {
+        this.#config = config;
+    }
+    get id() {
+        return this.#config.studio_id;
+    }
+    get region() {
+        return this.#config.region;
+    }
+    get project() {
+        return this.#config.project;
+    }
+    get name() {
+        return this.#config.title;
+    }
+    get avatar() {
+        return this.#config.emoji;
+    }
+    get description() {
+        return this.#config.description;
+    }
+    get parametersSchema() {
+        return this.#config.params_schema;
+    }
+}

package/esm/utils.d.ts

@@ -2,3 +2,4 @@ export declare function abortPromise(signal: AbortSignal, reject?: boolean): Pro
 export declare function delay(timeout: number | (() => number)): Promise<void>;
 export declare function cleanPath(path: string, version?: string): string;
 export declare function randomUUID(): Promise<any>;
+export declare function getFileExtension(filename: string): string;

package/esm/utils.js

@@ -15,3 +15,7 @@ export async function randomUUID() {
     const cryptoModule = await import("node:crypto");
     return cryptoModule.randomUUID();
 }
+export function getFileExtension(filename) {
+    const dot = filename.lastIndexOf(".");
+    return dot >= 0 ? filename.slice(dot + 1) : "";
+}

package/esm/workforce.d.ts

@@ -0,0 +1,22 @@
+import { Client } from "./client.js";
+import type { Region } from "./region.js";
+import { type Task } from "./task/task.js";
+type WorkforceConfig = {
+    id: string;
+    workforce_metadata: {
+        name: string;
+    };
+};
+export declare class Workforce {
+    #private;
+    static get(id: string, client?: Client): Promise<Workforce>;
+    private readonly client;
+    constructor(config: WorkforceConfig, client: Client);
+    get id(): string;
+    get region(): Region;
+    get project(): string;
+    get name(): string;
+    getTask(id: string): Promise<Task<Workforce>>;
+    sendMessage(message: string, task?: Task<Workforce>): Promise<Task<Workforce>>;
+}
+export {};

package/esm/workforce.js

@@ -0,0 +1,50 @@
+import { Client } from "./client.js";
+import { resetBackoffDuration } from "./task/task.js";
+import { WorkforceStrategy } from "./task/workforce-strategy.js";
+export class Workforce {
+    static async get(id, client = Client.default()) {
+        const config = await client.fetch(`/workforce/items/${id}`);
+        return new Workforce(config, client);
+    }
+    client;
+    #config;
+    constructor(config, client) {
+        this.#config = config;
+        this.client = client;
+    }
+    get id() {
+        return this.#config.id;
+    }
+    get region() {
+        return this.client.region;
+    }
+    get project() {
+        return this.client.project;
+    }
+    get name() {
+        return this.#config.workforce_metadata.name;
+    }
+    async getTask(id) {
+        return await WorkforceStrategy.get(id, this, this.client);
+    }
+    async sendMessage(message, task) {
+        const { workforce_task_id: taskId } = await this.client.fetch("/workforce/trigger", {
+            method: "POST",
+            body: JSON.stringify({
+                workforce_id: this.id,
+                workforce_task_id: task?.id,
+                trigger: {
+                    message: {
+                        role: "user",
+                        content: message,
+                        attachments: [],
+                    },
+                },
+            }),
+        });
+        if (task) {
+            task[resetBackoffDuration]();
+        }
+        return task ?? this.getTask(taskId);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relevanceai/sdk",
-  "version": "3.0.0-alpha.4",
+  "version": "3.0.0-alpha.6",
   "license": "MIT",
   "main": "./script/mod.js",
   "module": "./esm/mod.js",
@@ -11,5 +11,11 @@
     }
   },
   "scripts": {},
+  "dependencies": {
+    "json-schema": "^0.4.0"
+  },
+  "devDependencies": {
+    "@types/json-schema": "^7.0.15"
+  },
   "_generatedBy": "dnt@dev"
 }

package/script/agent.d.ts

@@ -1,29 +1,68 @@
-import { Client } from "./client.js";
+import { type Attachment, Client } from "./client.js";
 import type { Region } from "./region.js";
-import { Task } from "./task.js";
-interface AgentConfig {
+import { Task, type TaskStatus } from "./task/task.js";
+export interface AgentConfig {
     agent_id: string;
     public: boolean;
+    project: string;
     name?: string;
     description?: string;
     emoji?: string;
     insert_date_: string;
     update_date_: string;
+    model: string;
 }
+export type AgentTaskState = "idle" | "starting-up" | "running" | "pending-approval" | "waiting-for-capacity" | "cancelled" | "timed-out" | "escalated" | "unrecoverable" | "paused" | "completed" | "errored-pending-approval" | "queued-for-approval" | "queued-for-rerun";
+/**
+ * Converts an AgentTaskState to a simplified TaskStatus.
+ *
+ * @dev
+ *   We want to simplify because our states are simplified in the UI and also
+ *   some states have combined reasoning that the consumer does not need to care
+ *   about. i.e. "queued-for-approval" "queued-for-rerun" should just be "queued".
+ *
+ * @param {AgentTaskState} state The agent task state to convert.
+ * @returns {TaskStatus} The simplified task status.
+ */
+export declare function stateToStatus(state: AgentTaskState): TaskStatus;
+type SortDirection = "asc" | "desc";
+type GetTaskOptionSort = {
+    createdAt: SortDirection;
+} | {
+    updatedAt: SortDirection;
+};
+type GetTaskOptions = {
+    pageSize?: number;
+    page?: number;
+    sort?: GetTaskOptionSort;
+    search?: string;
+    filter?: {
+        status?: TaskStatus[];
+    };
+};
+type GetAllOptions = {
+    pageSize?: number;
+    page?: number;
+};
 export declare class Agent {
     #private;
-    private readonly client;
     static get(id: string, client?: Client): Promise<Agent>;
+    static getAll({ page, pageSize, }?: GetAllOptions, client?: Client): Promise<Agent[]>;
+    private readonly client;
     constructor(config: AgentConfig, client: Client);
     get id(): string;
+    get region(): Region;
+    get project(): string;
     get name(): string | undefined;
     get description(): string | undefined;
     get avatar(): string | undefined;
     get createdAt(): Date;
     get updatedAt(): Date;
-    get region(): Region;
-    get project(): string;
-    getTask(taskId: string): Promise<Task>;
-    sendMessage(message: string, task?: Task): Promise<Task>;
+    getTask(taskId: string): Promise<Task<Agent>>;
+    getTasks({ sort, pageSize, page, search, filter, }?: GetTaskOptions): Promise<Task<Agent>[]>;
+    sendMessage(message: string): Promise<Task<Agent>>;
+    sendMessage(message: string, task: Task<Agent>): Promise<Task<Agent>>;
+    sendMessage(message: string, attachments: (Attachment | File)[]): Promise<Task<Agent>>;
+    sendMessage(message: string, attachments: (Attachment | File)[], task: Task<Agent>): Promise<Task<Agent>>;
 }
 export {};

package/script/agent.js

@@ -1,20 +1,117 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
+exports.stateToStatus = stateToStatus;
 const client_js_1 = require("./client.js");
-const task_js_1 = require("./task.js");
 const utils_js_1 = require("./utils.js");
+const agent_strategy_js_1 = require("./task/agent-strategy.js");
+const task_js_1 = require("./task/task.js");
+/**
+ * Converts an AgentTaskState to a simplified TaskStatus.
+ *
+ * @dev
+ *   We want to simplify because our states are simplified in the UI and also
+ *   some states have combined reasoning that the consumer does not need to care
+ *   about. i.e. "queued-for-approval" "queued-for-rerun" should just be "queued".
+ *
+ * @param {AgentTaskState} state The agent task state to convert.
+ * @returns {TaskStatus} The simplified task status.
+ */
+function stateToStatus(state) {
+    switch (state) {
+        case "paused":
+            return "paused";
+        case "idle":
+            return "idle";
+        case "starting-up":
+        case "waiting-for-capacity":
+        case "queued-for-approval":
+        case "queued-for-rerun":
+            return "queued";
+        case "running":
+            return "running";
+        case "pending-approval":
+        case "escalated":
+            return "action";
+        case "timed-out":
+            return "error";
+        case "cancelled":
+            return "cancelled";
+        case "completed":
+            return "completed";
+        case "unrecoverable":
+        case "errored-pending-approval":
+            return "error";
+        default:
+            throw new Error(`unhandled task state: ${state}`);
+    }
+}
+/**
+ * Reverses {@link stateToStatus} returning the group of task states a _simplified_
+ * status may relate to.
+ *
+ * @see {stateToStatus}
+ * @param {TaskStatus} status
+ * @returns {AgentTaskState[]}
+ */
+function statusToStates(status) {
+    switch (status) {
+        case "not-started":
+            // a special sdk-only status
+            return [];
+        case "idle":
+            return ["idle"];
+        case "paused":
+            return ["paused"];
+        case "queued":
+            return [
+                "starting-up",
+                "waiting-for-capacity",
+                "queued-for-approval",
+                "queued-for-rerun",
+            ];
+        case "running":
+            return ["running"];
+        case "action":
+            return ["pending-approval", "escalated"];
+        case "completed":
+            return ["completed"];
+        case "cancelled":
+            return ["cancelled"];
+        case "error":
+            return ["errored-pending-approval", "timed-out", "unrecoverable"];
+    }
+}
+function taskSortOptionsToParam(sort) {
+    if ("createdAt" in sort) {
+        return { insert_date: sort.createdAt };
+    }
+    else if ("updatedAt" in sort) {
+        return { update_date: sort.updatedAt };
+    }
+    throw new Error("invalid sort option");
+}
 const taskPrefixDelimiter = "_-_";
 class Agent {
-    #config;
-    client;
     static async get(id, client = client_js_1.Client.default()) {
         const config = await Agent.#fetchConfig(id, client);
         return new Agent(config, client);
     }
+    static async getAll({ page = 1, pageSize = 20, } = {}, client = client_js_1.Client.default()) {
+        const { results } = await client.fetch("/agents/list", {
+            method: "POST",
+            body: JSON.stringify({
+                page_size: pageSize,
+                page,
+            }),
+        });
+        return results.map((config) => new Agent(config, client));
+    }
     static #fetchConfig(agentId, client = client_js_1.Client.default()) {
         return client.fetch(`/agents/${agentId}/get`).then(({ agent }) => agent);
     }
+    #config;
+    client;
     constructor(config, client) {
         this.client = client;
         this.#config = config;
@@ -22,6 +119,12 @@ class Agent {
     get id() {
         return this.#config.agent_id;
     }
+    get region() {
+        return this.client.region;
+    }
+    get project() {
+        return this.#config.project;
+    }
     get name() {
         return this.#config.name;
     }
@@ -37,16 +140,54 @@ class Agent {
     get updatedAt() {
         return new Date(this.#config.update_date_);
     }
-    get region() {
-        return this.client.region;
-    }
-    get project() {
-        return this.client.project;
-    }
     getTask(taskId) {
-        return task_js_1.Task.get(taskId, this, this.client);
+        return agent_strategy_js_1.AgentStrategy.get(taskId, this, this.client);
     }
-    async sendMessage(message, task) {
+    async getTasks({ sort = { createdAt: "asc" }, pageSize = 100, page = 1, search, filter, } = {}) {
+        const filtersParam = [{
+                condition: "==",
+                condition_value: [this.id],
+                field: "conversation.agent_id",
+                filter_type: "exact_match",
+            }];
+        if (filter) {
+            for (const [field, value] of Object.entries(filter)) {
+                switch (field) {
+                    case "status":
+                        filtersParam.push({
+                            condition: "==",
+                            condition_value: value.flatMap((s) => statusToStates(s)),
+                            field: "conversation.state",
+                            filter_type: "exact_match",
+                        });
+                }
+            }
+        }
+        const sortParam = taskSortOptionsToParam(sort);
+        const query = new URLSearchParams([
+            ["filters", JSON.stringify(filtersParam)],
+            ["sort", JSON.stringify([sortParam])],
+            ["page_size", pageSize.toString()],
+            ["page", page.toString()],
+        ]);
+        if (search?.trim()) {
+            query.set("query", search.trim());
+        }
+        const { results } = await this.client.fetch(`/agents/conversations/list?${query.toString()}`);
+        return results.map(({ metadata }) => new task_js_1.Task({
+            id: metadata.knowledge_set,
+            region: this.client.region,
+            project: this.client.project,
+            name: metadata.conversation.title,
+            status: stateToStatus(metadata.conversation.state),
+            createdAt: new Date(metadata.insert_date),
+            updatedAt: new Date(metadata.update_date),
+        }, new agent_strategy_js_1.AgentStrategy(metadata.knowledge_set, this, this.client)));
+    }
+    async sendMessage(message, attachOrTask, maybeTask) {
+        const hasAttachments = Array.isArray(attachOrTask);
+        const attachFiles = hasAttachments ? attachOrTask : [];
+        const task = hasAttachments ? maybeTask : attachOrTask;
         let taskId;
         // embed keys require a task prefixing for new tasks
         if (!task && this.client.isEmbedKey()) {
@@ -55,6 +196,10 @@ class Agent {
         else if (task) {
             taskId = task.id;
         }
+        const attachments = [];
+        for (const item of attachFiles) {
+            attachments.push(item instanceof File ? await this.client.uploadTempFile(item) : item);
+        }
         const res = await this.client.fetch("/agents/trigger", {
             method: "POST",
             body: JSON.stringify({
@@ -63,14 +208,17 @@ class Agent {
                 message: {
                     role: "user",
                     content: message,
-                    attachments: [], // @todo
+                    attachments: attachments.map(({ fileName, fileUrl }) => ({
+                        file_name: fileName,
+                        file_url: fileUrl,
+                    })),
                 },
             }),
         });
         if (task) {
-            task[task_js_1.resetSubscribeBackoff]();
+            task[task_js_1.resetBackoffDuration]();
         }
-        return task ?? this.getTask(res.conversation_id);
+        return task ?? await this.getTask(res.conversation_id);
     }
 }
 exports.Agent = Agent;

package/script/client.d.ts

@@ -5,6 +5,10 @@ type CreateClientOptions = {
     region: Region;
     project: string;
 };
+export type Attachment = {
+    fileName: string;
+    fileUrl: string;
+};
 /**
  * Creates and returns the _default_ client instance.
  *
@@ -26,7 +30,8 @@ export declare class Client {
     get region(): Region;
     get project(): string;
     isEmbedKey(): boolean;
-    fetch<T>(input: "/agents/trigger" | `/agents/${string}/get` | `/agents/${string}/tasks/${string}/metadata` | `/agents/${string}/tasks/${string}/view` | "/agents/conversations/list", init?: RequestInit): Promise<T>;
+    fetch<T>(input: "/agents/trigger" | `/agents/${string}/get` | `/agents/${string}/tasks/${string}/metadata` | `/agents/${string}/tasks/${string}/view` | "/agents/conversations/list" | "/services/get_temporary_file_upload_url" | `/workforce/items/${string}` | `/workforce/tasks/${string}/metadata` | `/workforce/items/${string}/tasks/${string}/messages` | "/workforce/trigger" | "/agents/list", init?: RequestInit): Promise<T>;
     url(path: string): URL;
+    uploadTempFile(file: File): Promise<Attachment>;
 }
 export {};

package/script/client.js

@@ -54,11 +54,16 @@ class Client {
     }
     async fetch(input, init) {
         const url = this.url(input);
-        const headers = new Headers(this.key.fetchHeaders());
-        const response = await fetch(url, Object.assign({ headers }, init));
+        const reqInit = Object.assign({}, init, {
+            headers: {
+                ...this.key.fetchHeaders(),
+                ...init?.headers,
+            },
+        });
+        const response = await fetch(url, reqInit);
         if (!response.ok) {
             const body = await response.text();
-            console.error(url, init, headers, body);
+            console.error("client#fetch(): request failed.", url, body, reqInit);
             throw new Error(response.statusText);
         }
         return response.json();
@@ -69,5 +74,34 @@ class Client {
         }
         return new URL((0, utils_js_1.cleanPath)(path), this.baseURL);
     }
+    async uploadTempFile(file) {
+        const { upload_url: uploadUrl, download_url: downloadUrl } = await this
+            .fetch("/services/get_temporary_file_upload_url", {
+            method: "POST",
+            body: JSON.stringify({
+                filename: file.name,
+                extension: (0, utils_js_1.getFileExtension)(file.name),
+            }),
+        });
+        let content = file.type;
+        if (file.type.startsWith("text/")) {
+            content += "; charset=utf-8"; // force utf-8 for text files
+        }
+        const response = await fetch(uploadUrl, {
+            method: "PUT",
+            body: file,
+            headers: {
+                "content-type": content,
+                "x-amz-tagging": "Expire=true",
+            },
+        });
+        if (!response.ok) {
+            throw new Error(response.statusText);
+        }
+        return {
+            fileName: file.name,
+            fileUrl: downloadUrl,
+        };
+    }
 }
 exports.Client = Client;

package/script/event.d.ts

@@ -1,33 +1,14 @@
 import type { AgentErrorMessage } from "./message/agent-error.js";
-import type { AgentMessage } from "./message/agent.js";
-import type { ToolMessage } from "./message/tool.js";
-import type { UserMessage } from "./message/user.js";
-import type { TaskStatus } from "./task.js";
-export declare class TaskStartEvent extends CustomEvent<{
-    id: string;
-    status: TaskStatus;
-}> {
-    readonly type = "start";
-    constructor(id: string, status: TaskStatus);
-}
-export declare class TaskStatusEvent extends CustomEvent<{
-    status: TaskStatus;
-}> {
-    readonly type = "status";
-    constructor(status: TaskStatus);
+import type { AnyTaskMessage } from "./message/task.js";
+export declare class TaskUpdateEvent extends CustomEvent<void> {
+    readonly type = "update";
+    constructor();
 }
 export declare class TaskMessageEvent extends CustomEvent<{
-    message: AgentMessage | UserMessage;
+    message: AnyTaskMessage;
 }> {
     readonly type = "message";
-    constructor(message: AgentMessage | UserMessage);
-    isUserMessage(): boolean;
-}
-export declare class TaskUpdateEvent extends CustomEvent<{
-    message: ToolMessage;
-}> {
-    readonly type = "update";
-    constructor(message: ToolMessage);
+    constructor(message: AnyTaskMessage);
 }
 export declare class TaskErrorEvent extends CustomEvent<{
     message: AgentErrorMessage;

package/script/event.js

@@ -1,37 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TaskErrorEvent = exports.TaskUpdateEvent = exports.TaskMessageEvent = exports.TaskStatusEvent = exports.TaskStartEvent = void 0;
-class TaskStartEvent extends CustomEvent {
-    type = "start";
-    constructor(id, status) {
-        super("start", { detail: { id, status } });
-    }
-}
-exports.TaskStartEvent = TaskStartEvent;
-class TaskStatusEvent extends CustomEvent {
-    type = "status";
-    constructor(status) {
-        super("status", { detail: { status } });
+exports.TaskErrorEvent = exports.TaskMessageEvent = exports.TaskUpdateEvent = void 0;
+class TaskUpdateEvent extends CustomEvent {
+    type = "update";
+    constructor() {
+        super("update");
     }
 }
-exports.TaskStatusEvent = TaskStatusEvent;
+exports.TaskUpdateEvent = TaskUpdateEvent;
 class TaskMessageEvent extends CustomEvent {
     type = "message";
     constructor(message) {
         super("message", { detail: { message } });
     }
-    isUserMessage() {
-        return this.detail.message.type === "user-message";
-    }
 }
 exports.TaskMessageEvent = TaskMessageEvent;
-class TaskUpdateEvent extends CustomEvent {
-    type = "update";
-    constructor(message) {
-        super("update", { detail: { message } });
-    }
-}
-exports.TaskUpdateEvent = TaskUpdateEvent;
 class TaskErrorEvent extends CustomEvent {
     type = "error";
     constructor(message) {

package/script/key.d.ts

@@ -1,4 +1,4 @@
-import type { Region } from "./mod.js";
+import type { Region } from "./region.js";
 type CreateKeyOptions = {
     key: string;
     region: Region;

package/script/message/agent-error.d.ts

@@ -1,6 +1,11 @@
-import { TaskMessage } from "./task.js";
+import { GenericMessage } from "./task.js";
 export interface AgentErrorMessageContent {
     type: "agent-error";
+    errors: {
+        body: string;
+    }[];
 }
-export declare class AgentErrorMessage extends TaskMessage<AgentErrorMessageContent> {
+export declare class AgentErrorMessage extends GenericMessage<AgentErrorMessageContent> {
+    get errors(): string[];
+    get lastError(): string;
 }

package/script/message/agent-error.js

@@ -2,6 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentErrorMessage = void 0;
 const task_js_1 = require("./task.js");
-class AgentErrorMessage extends task_js_1.TaskMessage {
+class AgentErrorMessage extends task_js_1.GenericMessage {
+    get errors() {
+        return this.message.content.errors.map((e) => e.body);
+    }
+    get lastError() {
+        return this.errors.at(-1);
+    }
 }
 exports.AgentErrorMessage = AgentErrorMessage;

package/script/message/agent.d.ts

@@ -1,9 +1,9 @@
-import { TaskMessage } from "./task.js";
+import { GenericMessage } from "./task.js";
 export interface AgentMessageContent {
     type: "agent-message";
     text: string;
 }
-export declare class AgentMessage extends TaskMessage<AgentMessageContent> {
+export declare class AgentMessage extends GenericMessage<AgentMessageContent> {
     get text(): string;
     get agentId(): string;
 }

package/script/message/agent.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentMessage = void 0;
 const task_js_1 = require("./task.js");
-class AgentMessage extends task_js_1.TaskMessage {
+class AgentMessage extends task_js_1.GenericMessage {
     get text() {
         return this.message.content.text;
     }