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

package/script/message/user.js

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UserMessage = void 0;
 const task_js_1 = require("./task.js");
-class UserMessage extends task_js_1.TaskMessage {
+class UserMessage extends task_js_1.GenericMessage {
     /**
      * The message as text sent.
      *

package/script/message/workforce-agent-handover.d.ts

@@ -0,0 +1,23 @@
+import { GenericMessage } from "./task.js";
+export interface WorkforceAgentHandoverMessageContent {
+    type: "workforce-agent-handover";
+    task_details?: {
+        project: string;
+        region: string;
+        conversation_id: string;
+    };
+    agent_details: {
+        agent_id: string;
+        project: string;
+        region: string;
+        name?: string;
+        emoji?: string;
+        description?: string;
+        deleted_reason?: "entity_deleted";
+    };
+    trigger: {
+        message: string;
+    };
+}
+export declare class WorkforceAgentHandoverMessage extends GenericMessage<WorkforceAgentHandoverMessageContent> {
+}

package/script/message/workforce-agent-handover.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkforceAgentHandoverMessage = void 0;
+const task_js_1 = require("./task.js");
+class WorkforceAgentHandoverMessage extends task_js_1.GenericMessage {
+}
+exports.WorkforceAgentHandoverMessage = WorkforceAgentHandoverMessage;

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

@@ -0,0 +1,23 @@
+import type { AgentTaskState } from "../agent.js";
+import { GenericMessage } from "./task.js";
+export interface WorkforceAgentMessageContent {
+    type: "workforce-agent-run";
+    task_details: {
+        project: string;
+        region: string;
+        conversation_id: string;
+        finished_state?: AgentTaskState;
+        current_state?: AgentTaskState;
+    };
+    agent_details?: {
+        agent_id: string;
+        project: string;
+        region: string;
+        name?: string;
+        emoji?: string;
+        description?: string;
+        deleted_reason?: "entity_deleted";
+    };
+}
+export declare class WorkforceAgentMessage extends GenericMessage<WorkforceAgentMessageContent> {
+}

package/script/message/workforce-agent.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkforceAgentMessage = void 0;
+const task_js_1 = require("./task.js");
+class WorkforceAgentMessage extends task_js_1.GenericMessage {
+}
+exports.WorkforceAgentMessage = WorkforceAgentMessage;

package/script/mod.d.ts

@@ -2,9 +2,4 @@ export { Agent } from "./agent.js";
 export { Client, createClient } from "./client.js";
 export { Key } from "./key.js";
 export { type Region, REGION_AU, REGION_EU, REGION_US } from "./region.js";
-export { Task, type TaskStatus } from "./task.js";
-export type { AgentErrorMessage } from "./message/agent-error.js";
-export type { AgentMessage } from "./message/agent.js";
-export type { ToolMessage } from "./message/tool.js";
-export type { UserMessage } from "./message/user.js";
-export type { AnyTaskMessage } from "./message/task.js";
+export { Workforce } from "./workforce.js";

package/script/mod.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Task = exports.REGION_US = exports.REGION_EU = exports.REGION_AU = exports.Key = exports.createClient = exports.Client = exports.Agent = void 0;
+exports.Workforce = exports.REGION_US = exports.REGION_EU = exports.REGION_AU = exports.Key = exports.createClient = exports.Client = exports.Agent = void 0;
 var agent_js_1 = require("./agent.js");
 Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_js_1.Agent; } });
 var client_js_1 = require("./client.js");
@@ -12,5 +12,5 @@ var region_js_1 = require("./region.js");
 Object.defineProperty(exports, "REGION_AU", { enumerable: true, get: function () { return region_js_1.REGION_AU; } });
 Object.defineProperty(exports, "REGION_EU", { enumerable: true, get: function () { return region_js_1.REGION_EU; } });
 Object.defineProperty(exports, "REGION_US", { enumerable: true, get: function () { return region_js_1.REGION_US; } });
-var task_js_1 = require("./task.js");
-Object.defineProperty(exports, "Task", { enumerable: true, get: function () { return task_js_1.Task; } });
+var workforce_js_1 = require("./workforce.js");
+Object.defineProperty(exports, "Workforce", { enumerable: true, get: function () { return workforce_js_1.Workforce; } });

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

@@ -0,0 +1,26 @@
+import { type Agent, type AgentTaskState } from "../agent.js";
+import { Client } from "../client.js";
+import type { AnyTaskMessage } from "../message/task.js";
+import { Task, type TaskMetadata, type TaskStrategy } from "./task.js";
+export type AgentTaskMetadata = {
+    knowledge_set: string;
+    insert_date: string;
+    update_date: string;
+    conversation: {
+        created_by_user_id: string;
+        state: AgentTaskState;
+        title: string;
+    };
+};
+export declare class AgentStrategy implements TaskStrategy<Agent> {
+    static get(id: string, agent: Agent, client?: Client): Promise<Task<Agent>>;
+    private readonly id;
+    private readonly agent;
+    private readonly client;
+    constructor(id: string, agent: Agent, client: Client);
+    get subject(): Agent;
+    getMetadata(): Promise<TaskMetadata>;
+    getMessages({ after }?: {
+        after?: Date;
+    }): Promise<AnyTaskMessage[]>;
+}

package/script/task/agent-strategy.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentStrategy = void 0;
+const agent_js_1 = require("../agent.js");
+const client_js_1 = require("../client.js");
+const agent_error_js_1 = require("../message/agent-error.js");
+const agent_js_2 = require("../message/agent.js");
+const tool_js_1 = require("../message/tool.js");
+const user_js_1 = require("../message/user.js");
+const task_js_1 = require("./task.js");
+class AgentStrategy {
+    static async get(id, agent, client = client_js_1.Client.default()) {
+        const subject = new this(id, agent, client);
+        return new task_js_1.Task(await subject.getMetadata(), subject);
+    }
+    id;
+    agent;
+    client;
+    constructor(id, agent, client) {
+        this.id = id;
+        this.agent = agent;
+        this.client = client;
+    }
+    get subject() {
+        return this.agent;
+    }
+    async getMetadata() {
+        const { metadata } = await this.client.fetch(`/agents/${this.agent.id}/tasks/${this.id}/metadata`);
+        return {
+            id: this.id,
+            region: this.client.region,
+            project: this.client.project,
+            name: metadata.conversation.title,
+            status: (0, agent_js_1.stateToStatus)(metadata.conversation.state),
+            createdAt: new Date(metadata.insert_date),
+            updatedAt: new Date(metadata.update_date),
+        };
+    }
+    async getMessages({ after = new Date(0) } = {}) {
+        const url = `/agents/${this.agent.id}/tasks/${this.id}/view`;
+        const res = await this.client.fetch(url, {
+            method: "POST",
+            body: JSON.stringify({
+                page_size: 1_000, // @todo: pagination
+                cursor: {
+                    after: after.toISOString(),
+                },
+            }),
+        });
+        // message should be in ascending order
+        return res.results.reverse().map((data) => {
+            switch (data.content.type) {
+                case "agent-error":
+                    return new agent_error_js_1.AgentErrorMessage(data);
+                case "agent-message":
+                    return new agent_js_2.AgentMessage(data);
+                case "tool-run":
+                    return new tool_js_1.ToolMessage(data);
+                case "user-message":
+                    return new user_js_1.UserMessage(data);
+                default:
+                    throw new Error("unknown message response");
+            }
+        });
+    }
+}
+exports.AgentStrategy = AgentStrategy;

package/script/task/task.d.ts

@@ -0,0 +1,59 @@
+import { Emitter } from "../emitter.js";
+import type { AnyTaskMessage } from "../message/task.js";
+import type { Region } from "../region.js";
+import type { Workforce } from "../workforce.js";
+import type { Agent } from "../agent.js";
+import type { AgentErrorMessage } from "../message/agent-error.js";
+export type TaskStatus = "not-started" | "idle" | "paused" | "queued" | "running" | "action" | "completed" | "cancelled" | "error";
+export interface TaskMetadata {
+    id: string;
+    region: Region;
+    project: string;
+    status: TaskStatus;
+    name: string;
+    createdAt: Date;
+    updatedAt: Date;
+}
+type TaskEventMap = {
+    updated: undefined;
+    message: {
+        message: AnyTaskMessage;
+    };
+    error: {
+        message: AgentErrorMessage;
+    };
+};
+export interface TaskStrategy<S> {
+    subject: S;
+    getMessages(options?: {
+        after?: Date;
+    }): Promise<AnyTaskMessage[]>;
+    getMetadata(): Promise<TaskMetadata>;
+}
+export declare const resetBackoffDuration: unique symbol;
+export declare class Task<S extends Agent | Workforce, E extends TaskEventMap = TaskEventMap> extends Emitter<E> {
+    #private;
+    private subscribed;
+    private backoff;
+    private backoffDuration;
+    private readonly strategy;
+    constructor(metadata: TaskMetadata, strategy: TaskStrategy<S>);
+    get subject(): S;
+    get id(): string;
+    get region(): Region;
+    get project(): string;
+    get name(): string;
+    get status(): TaskStatus;
+    get createdAt(): Date;
+    get updatedAt(): Date;
+    getMessages(options?: {
+        after?: Date;
+    }): Promise<AnyTaskMessage[]>;
+    isRunning(): boolean;
+    unsubscribe(): void;
+    [resetBackoffDuration](): 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;
+}
+export {};

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.TaskUpdatedEvent());
+                        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/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;