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

package/script/task/task.js

@@ -0,0 +1,170 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Task = exports.resetBackoffDuration = void 0;
+const emitter_js_1 = require("../emitter.js");
+const utils_js_1 = require("../utils.js");
+const event_js_1 = require("../event.js");
+exports.resetBackoffDuration = Symbol("resetBackoffDuration");
+const backoffStartingDuration = 1_000;
+const backoffMaxDuration = 60_000;
+class Task extends emitter_js_1.Emitter {
+    subscribed = null;
+    backoff = null;
+    backoffDuration = 0;
+    strategy;
+    #metadata;
+    constructor(metadata, strategy) {
+        super();
+        this.strategy = strategy;
+        this.#metadata = metadata;
+    }
+    get subject() {
+        return this.strategy.subject;
+    }
+    get id() {
+        return this.#metadata.id;
+    }
+    get region() {
+        return this.#metadata.region;
+    }
+    get project() {
+        return this.#metadata.project;
+    }
+    get name() {
+        return this.#metadata.name;
+    }
+    get status() {
+        return this.#metadata.status;
+    }
+    get createdAt() {
+        return this.#metadata.createdAt;
+    }
+    get updatedAt() {
+        return this.#metadata.updatedAt;
+    }
+    getMessages(options) {
+        return this.strategy.getMessages(options);
+    }
+    isRunning() {
+        switch (this.status) {
+            case "queued":
+            case "running":
+                return true;
+            default:
+                return false;
+        }
+    }
+    #subscribe() {
+        if (this.subscribed) {
+            return;
+        }
+        const subscribed = new AbortController();
+        this.subscribed = subscribed; // subscribed ref
+        const isSubscribed = () => !subscribed.signal.aborted;
+        this.backoffDuration = backoffStartingDuration;
+        const cursor = new Date(0);
+        const emitted = new Set();
+        const pending = new Map();
+        void (async () => {
+            while (isSubscribed()) {
+                try {
+                    const [metadata, messages] = await Promise.all([
+                        this.strategy.getMetadata(),
+                        this.strategy.getMessages({ after: cursor }),
+                    ]);
+                    if (!isSubscribed()) {
+                        break;
+                    }
+                    let hasChanges = false;
+                    if (metadata.updatedAt > this.updatedAt) {
+                        this.dispatchEvent(new event_js_1.TaskUpdateEvent());
+                        hasChanges = true;
+                    }
+                    this.#metadata = metadata;
+                    if (messages.length) {
+                        for (const message of messages) {
+                            if (emitted.has(message.id)) {
+                                continue;
+                            }
+                            switch (message.type) {
+                                case "agent-error":
+                                    emitted.add(message.id);
+                                    this.dispatchEvent(new event_js_1.TaskErrorEvent(message));
+                                    break;
+                                case "tool-run": {
+                                    const { status } = message;
+                                    if (pending.get(message.id)?.status == status) {
+                                        // no change to the tool status
+                                        continue;
+                                    }
+                                    if (["pending", "running"].includes(status)) {
+                                        pending.set(message.id, message);
+                                    }
+                                    else {
+                                        emitted.add(message.id);
+                                        pending.delete(message.id);
+                                    }
+                                    this.dispatchEvent(new event_js_1.TaskMessageEvent(message));
+                                    break;
+                                }
+                                case "agent-message":
+                                case "user-message":
+                                    hasChanges = true;
+                                    emitted.add(message.id);
+                                    this.dispatchEvent(new event_js_1.TaskMessageEvent(message));
+                            }
+                        }
+                        let latest = messages.at(-1).createdAt;
+                        for (const message of pending.values()) {
+                            if (latest > message.createdAt) {
+                                latest = message.createdAt;
+                            }
+                        }
+                        cursor.setTime(latest.getTime());
+                    }
+                    if (hasChanges) {
+                        this.backoffDuration = backoffStartingDuration;
+                    }
+                    else if (!this.isRunning()) {
+                        this.backoffDuration = Math.min(this.backoffDuration * 2, backoffMaxDuration);
+                    }
+                }
+                finally {
+                    if (isSubscribed()) {
+                        const backoff = new AbortController();
+                        this.backoff = backoff;
+                        await Promise.race([
+                            (0, utils_js_1.delay)(this.backoffDuration),
+                            (0, utils_js_1.abortPromise)(AbortSignal.any([subscribed.signal, backoff.signal])),
+                        ]);
+                    }
+                }
+            }
+        })();
+    }
+    unsubscribe() {
+        this.subscribed?.abort();
+        this.subscribed = null;
+        this.backoff?.abort();
+        this.backoff = null;
+        this.backoffDuration = 0;
+    }
+    [exports.resetBackoffDuration]() {
+        this.backoffDuration = backoffStartingDuration;
+    }
+    addEventListener(type, listener, options) {
+        this.#subscribe();
+        const signal = AbortSignal.any([
+            ...(options && typeof options === "object" && options.signal
+                ? [options.signal]
+                : []),
+            ...(this.subscribed ? [this.subscribed.signal] : []),
+        ]);
+        const capture = typeof options === "boolean"
+            ? options
+            : Boolean(options?.capture);
+        const addOptions = Object.assign({}, options, { signal, capture });
+        super.addEventListener(type, listener, addOptions);
+    }
+}
+exports.Task = Task;

package/script/task/workforce-strategy.d.ts

@@ -0,0 +1,17 @@
+import type { AnyTaskMessage } from "../message/task.js";
+import { Client } from "../client.js";
+import { Task, type TaskMetadata, type TaskStatus, type TaskStrategy } from "./task.js";
+import type { Workforce } from "../workforce.js";
+export declare class WorkforceStrategy implements TaskStrategy<Workforce> {
+    static get(id: string, workforce: Workforce, client?: Client): Promise<Task<Workforce>>;
+    static convertStatus(): TaskStatus;
+    private readonly id;
+    private readonly workforce;
+    private readonly client;
+    private constructor();
+    get subject(): Workforce;
+    getMessages({ after: _after }: {
+        after?: Date;
+    }): Promise<AnyTaskMessage[]>;
+    getMetadata(): Promise<TaskMetadata>;
+}

package/script/task/workforce-strategy.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkforceStrategy = void 0;
+const client_js_1 = require("../client.js");
+const task_js_1 = require("./task.js");
+const agent_error_js_1 = require("../message/agent-error.js");
+const agent_js_1 = require("../message/agent.js");
+const tool_js_1 = require("../message/tool.js");
+const user_js_1 = require("../message/user.js");
+const workforce_agent_js_1 = require("../message/workforce-agent.js");
+const workforce_agent_handover_js_1 = require("../message/workforce-agent-handover.js");
+class WorkforceStrategy {
+    static async get(id, workforce, client = client_js_1.Client.default()) {
+        const subject = new this(id, workforce, client);
+        const metadata = await subject.getMetadata();
+        return new task_js_1.Task(metadata, subject);
+    }
+    static convertStatus() {
+        return "not-implemented";
+    }
+    id;
+    workforce;
+    client;
+    constructor(id, workforce, client) {
+        this.id = id;
+        this.workforce = workforce;
+        this.client = client;
+    }
+    get subject() {
+        return this.workforce;
+    }
+    async getMessages({ after: _after }) {
+        const { results } = await this.client.fetch(`/workforce/items/${this.workforce.id}/tasks/${this.id}/messages`, {
+            method: "POST",
+            body: JSON.stringify({
+                page_size: 1_000, // @todo: pagination
+                // @todo: cursor "before" :S
+            }),
+        });
+        return results.map((data) => {
+            switch (data.content.type) {
+                case "agent-error":
+                    return new agent_error_js_1.AgentErrorMessage(data);
+                case "agent-message":
+                    return new agent_js_1.AgentMessage(data);
+                case "tool-run":
+                    return new tool_js_1.ToolMessage(data);
+                case "user-message":
+                    return new user_js_1.UserMessage(data);
+                case "workforce-agent-run":
+                    return new workforce_agent_js_1.WorkforceAgentMessage(data);
+                case "workforce-agent-handover":
+                    return new workforce_agent_handover_js_1.WorkforceAgentHandoverMessage(data);
+                default:
+                    throw new Error("unknown message response");
+            }
+        });
+    }
+    async getMetadata() {
+        const { metadata } = await this.client.fetch(`/workforce/tasks/${this.id}/metadata`);
+        return {
+            id: this.id,
+            region: this.client.region,
+            project: this.client.project,
+            name: metadata.title,
+            status: WorkforceStrategy.convertStatus(), // @todo: not implemented
+            createdAt: new Date(metadata.insert_date),
+            updatedAt: new Date(metadata.update_date),
+        };
+    }
+}
+exports.WorkforceStrategy = WorkforceStrategy;

package/script/tool.d.ts

@@ -0,0 +1,22 @@
+import type { Region } from "./region.js";
+import type { JSONSchema4 } from "json-schema";
+export type ToolConfig = {
+    region: Region;
+    project: string;
+    studio_id: string;
+    title: string;
+    description: string;
+    emoji?: string;
+    params_schema: JSONSchema4;
+};
+export declare class Tool {
+    #private;
+    constructor(config: ToolConfig);
+    get id(): string;
+    get region(): Region;
+    get project(): string;
+    get name(): string;
+    get avatar(): string | undefined;
+    get description(): string | undefined;
+    get parametersSchema(): JSONSchema4;
+}

package/script/tool.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tool = void 0;
+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;
+    }
+}
+exports.Tool = Tool;

package/script/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/script/utils.js

@@ -37,6 +37,7 @@ exports.abortPromise = abortPromise;
 exports.delay = delay;
 exports.cleanPath = cleanPath;
 exports.randomUUID = randomUUID;
+exports.getFileExtension = getFileExtension;
 function abortPromise(signal, reject) {
     return new Promise((res, rej) => signal.addEventListener("abort", () => reject ? rej() : res()));
 }
@@ -54,3 +55,7 @@ async function randomUUID() {
     const cryptoModule = await Promise.resolve().then(() => __importStar(require("node:crypto")));
     return cryptoModule.randomUUID();
 }
+function getFileExtension(filename) {
+    const dot = filename.lastIndexOf(".");
+    return dot >= 0 ? filename.slice(dot + 1) : "";
+}

package/script/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/script/workforce.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Workforce = void 0;
+const client_js_1 = require("./client.js");
+const task_js_1 = require("./task/task.js");
+const workforce_strategy_js_1 = require("./task/workforce-strategy.js");
+class Workforce {
+    static async get(id, client = client_js_1.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 workforce_strategy_js_1.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[task_js_1.resetBackoffDuration]();
+        }
+        return task ?? this.getTask(taskId);
+    }
+}
+exports.Workforce = Workforce;

package/esm/task.d.ts

@@ -1,57 +0,0 @@
-import { Agent } from "./agent.js";
-import { Client } from "./client.js";
-import { Emitter } from "./emitter.js";
-import { AgentMessage } from "./message/agent.js";
-import type { AnyTaskMessage } from "./message/task.js";
-import { ToolMessage } from "./message/tool.js";
-import { UserMessage } from "./message/user.js";
-export type TaskState = "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";
-export type TaskStatus = "not-started" | "idle" | "queued" | "running" | "action" | "complete" | "error";
-type TaskMetadata = {
-    knowledge_set: string;
-    insert_date: string;
-    update_date: string;
-    conversation: {
-        created_by_user_id: string;
-        state: TaskState;
-        title: string;
-    };
-};
-type TaskEventMap = {
-    start: {
-        status: TaskStatus;
-    };
-    status: {
-        status: TaskStatus;
-    };
-    message: {
-        message: AgentMessage | UserMessage;
-    };
-    update: {
-        message: ToolMessage;
-    };
-};
-export declare const resetSubscribeBackoff: unique symbol;
-export declare class Task extends Emitter<TaskEventMap> {
-    #private;
-    static get(id: string, agentOrAgentId: Agent | string, client?: Client): Promise<Task>;
-    readonly agent: Agent;
-    protected readonly client: Client;
-    protected constructor(metadata: TaskMetadata, agent: Agent, client?: Client);
-    get id(): string;
-    get title(): string;
-    get status(): TaskStatus;
-    isRunning(): boolean;
-    getMessages({ from }?: {
-        from?: Date;
-    }): Promise<AnyTaskMessage[]>;
-    protected refresh(): Promise<void>;
-    [resetSubscribeBackoff](): void;
-    subscribe(): void;
-    protected isSubscribed(): boolean;
-    unsubscribe(): void;
-    addEventListener<K extends keyof TaskEventMap>(type: Extract<K, string>, listener: ((event: CustomEvent<TaskEventMap[K]>) => void) | {
-        handleEvent: (event: CustomEvent<TaskEventMap[K]>) => void;
-    } | null, options?: boolean | AddEventListenerOptions): void;
-}
-export {};