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

package/esm/task.js

@@ -1,259 +0,0 @@
-import { Agent } from "./agent.js";
-import { Client } from "./client.js";
-import { Emitter } from "./emitter.js";
-import { TaskErrorEvent, TaskMessageEvent, TaskStatusEvent, TaskUpdateEvent, } from "./event.js";
-import { AgentErrorMessage, } from "./message/agent-error.js";
-import { AgentMessage } from "./message/agent.js";
-import { ToolMessage } from "./message/tool.js";
-import { UserMessage } from "./message/user.js";
-import { abortPromise, delay } from "./utils.js";
-/**
- * Converts an AgentTaskState to a simplified TaskStatus.
- *
- * @internal
- *
- * @param {AgentTaskState} state The agent task state to convert.
- * @returns {TaskStatus} The simplified task status.
- */
-function stateToStatus(state) {
-    switch (state) {
-        case "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":
-        case "completed":
-            return "complete";
-        case "unrecoverable":
-        case "errored-pending-approval":
-            return "error";
-        default:
-            throw new Error(`unhandled task state: ${state}`);
-    }
-}
-export const resetSubscribeBackoff = Symbol("resetSubscribeBackoff");
-export class Task extends Emitter {
-    static async get(id, agentOrAgentId, client = Client.default()) {
-        const agent = typeof agentOrAgentId === "string"
-            ? await Agent.get(agentOrAgentId, client)
-            : agentOrAgentId;
-        const metadata = await Task.#fetchMetadata(id, agent.id, client);
-        return new Task(metadata, agent, client);
-    }
-    static #fetchMetadata(id, agentId, client) {
-        return client.fetch(`/agents/${agentId}/tasks/${id}/metadata`).then(({ metadata }) => metadata);
-    }
-    #controller;
-    #backoffMs = 1000;
-    #lastUpdatedAt;
-    #delayController;
-    #metadata;
-    agent;
-    client;
-    constructor(metadata, agent, client = Client.default()) {
-        super();
-        this.#metadata = metadata;
-        this.agent = agent;
-        this.client = client;
-    }
-    get id() {
-        return this.#metadata.knowledge_set;
-    }
-    get title() {
-        return this.#metadata.conversation.title ?? "";
-    }
-    get status() {
-        return stateToStatus(this.#metadata.conversation.state);
-    }
-    isRunning() {
-        switch (this.status) {
-            case "queued":
-            case "running":
-                return true;
-            default:
-                return false;
-        }
-    }
-    async getMessages({ from = 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: from.toISOString(),
-                },
-            }),
-        });
-        // message should be in ascending order
-        return res.results.reverse().map((data) => {
-            switch (data.content.type) {
-                case "agent-error":
-                    return new AgentErrorMessage(data);
-                case "agent-message":
-                    return new AgentMessage(data);
-                case "tool-run":
-                    return new ToolMessage(data);
-                case "user-message":
-                    return new UserMessage(data);
-                default:
-                    throw new Error("unknown message response");
-            }
-        });
-    }
-    async refresh() {
-        this.#metadata = await Task.#fetchMetadata(this.id, this.agent.id, this.client);
-    }
-    [resetSubscribeBackoff]() {
-        this.#backoffMs = 1000;
-        this.#delayController?.abort();
-    }
-    subscribe() {
-        if (this.isSubscribed()) {
-            return;
-        }
-        this.#controller = new AbortController();
-        const signal = this.#controller.signal;
-        let currentStatus = this.status;
-        const messagesCursor = new Date(0);
-        const emitted = new Set();
-        let lastMessage = null;
-        const pendingTools = new Map();
-        // Initialize backoff and tracking
-        this.#backoffMs = 1000;
-        this.#lastUpdatedAt = this.#metadata.update_date;
-        void (async () => {
-            while (this.isSubscribed() && !signal.aborted) {
-                try {
-                    const [, result] = await Promise.allSettled([
-                        this.refresh(),
-                        this.getMessages({ from: messagesCursor }),
-                    ]);
-                    if (!this.isSubscribed() || signal.aborted) {
-                        break;
-                    }
-                    const messages = result.status === "fulfilled" ? result.value : [];
-                    // Track if any changes occurred
-                    let hasChanges = false;
-                    // Check for status changes
-                    if (this.status !== currentStatus) {
-                        currentStatus = this.status;
-                        this.dispatchEvent(new TaskStatusEvent(this.status));
-                        hasChanges = true;
-                    }
-                    // Check for metadata update_date changes
-                    if (this.#metadata.update_date !== this.#lastUpdatedAt) {
-                        this.#lastUpdatedAt = this.#metadata.update_date;
-                        hasChanges = true;
-                    }
-                    // Process messages
-                    if (messages.length) {
-                        hasChanges = true;
-                        for (const message of messages) {
-                            if (emitted.has(message.id)) {
-                                switch (message.type) {
-                                    case "agent-error":
-                                    case "agent-message":
-                                    case "user-message":
-                                        // don't re-fire
-                                        continue;
-                                }
-                            }
-                            emitted.add(message.id);
-                            switch (message.type) {
-                                case "agent-error":
-                                    this.dispatchEvent(new TaskErrorEvent(message));
-                                    break;
-                                case "tool-run": {
-                                    const { status } = message;
-                                    if (pendingTools.get(message.id)?.status == status) {
-                                        // no change to the tool status
-                                        continue;
-                                    }
-                                    if (["pending", "running"].includes(status)) {
-                                        pendingTools.set(message.id, message);
-                                    }
-                                    else {
-                                        pendingTools.delete(message.id);
-                                    }
-                                    this.dispatchEvent(new TaskUpdateEvent(message));
-                                    break;
-                                }
-                                case "agent-message":
-                                case "user-message":
-                                    this.dispatchEvent(new TaskMessageEvent(message));
-                            }
-                            lastMessage = message;
-                        }
-                        // +1 the api treats after inclusively
-                        let nextCursor = messages.at(-1).createdAt.getTime() + 1;
-                        // set the cursor as the earliest pending tool
-                        for (const pending of pendingTools.values()) {
-                            if (nextCursor > pending.createdAt.getTime()) {
-                                nextCursor = pending.createdAt.getTime();
-                            }
-                        }
-                        messagesCursor.setTime(nextCursor);
-                    }
-                    // Apply backoff logic
-                    if (hasChanges) {
-                        // Reset backoff on any changes
-                        this.#backoffMs = 1000;
-                    }
-                    else if (!this.isRunning() && lastMessage?.isAgent()) {
-                        // Apply exponential backoff when idle with last message from agent
-                        this.#backoffMs = Math.min(this.#backoffMs * 2, 60000);
-                    }
-                }
-                finally {
-                    // Wait for the backoff period or abort signal
-                    if (!signal.aborted) {
-                        // Create a new controller for this delay that can be aborted independently
-                        this.#delayController = new AbortController();
-                        await Promise.race([
-                            delay(this.#backoffMs),
-                            abortPromise(AbortSignal.any([
-                                signal,
-                                this.#delayController.signal,
-                            ])),
-                        ]);
-                    }
-                }
-            }
-        })();
-    }
-    isSubscribed() {
-        return this.#controller !== undefined;
-    }
-    unsubscribe() {
-        this.#delayController?.abort();
-        this.#controller?.abort();
-        this.#delayController = undefined;
-        this.#controller = undefined;
-    }
-    addEventListener(type, listener, options) {
-        this.subscribe();
-        const signal = AbortSignal.any([
-            ...(options && typeof options === "object" && options.signal
-                ? [options.signal]
-                : []),
-            this.#controller.signal,
-        ]);
-        const capture = typeof options === "boolean"
-            ? options
-            : Boolean(options?.capture);
-        const addOptions = Object.assign({}, options, { signal, capture });
-        super.addEventListener(type, listener, addOptions);
-    }
-}

package/script/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 {};

package/script/task.js

@@ -1,263 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Task = exports.resetSubscribeBackoff = void 0;
-const agent_js_1 = require("./agent.js");
-const client_js_1 = require("./client.js");
-const emitter_js_1 = require("./emitter.js");
-const event_js_1 = require("./event.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 utils_js_1 = require("./utils.js");
-/**
- * Converts an AgentTaskState to a simplified TaskStatus.
- *
- * @internal
- *
- * @param {AgentTaskState} state The agent task state to convert.
- * @returns {TaskStatus} The simplified task status.
- */
-function stateToStatus(state) {
-    switch (state) {
-        case "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":
-        case "completed":
-            return "complete";
-        case "unrecoverable":
-        case "errored-pending-approval":
-            return "error";
-        default:
-            throw new Error(`unhandled task state: ${state}`);
-    }
-}
-exports.resetSubscribeBackoff = Symbol("resetSubscribeBackoff");
-class Task extends emitter_js_1.Emitter {
-    static async get(id, agentOrAgentId, client = client_js_1.Client.default()) {
-        const agent = typeof agentOrAgentId === "string"
-            ? await agent_js_1.Agent.get(agentOrAgentId, client)
-            : agentOrAgentId;
-        const metadata = await Task.#fetchMetadata(id, agent.id, client);
-        return new Task(metadata, agent, client);
-    }
-    static #fetchMetadata(id, agentId, client) {
-        return client.fetch(`/agents/${agentId}/tasks/${id}/metadata`).then(({ metadata }) => metadata);
-    }
-    #controller;
-    #backoffMs = 1000;
-    #lastUpdatedAt;
-    #delayController;
-    #metadata;
-    agent;
-    client;
-    constructor(metadata, agent, client = client_js_1.Client.default()) {
-        super();
-        this.#metadata = metadata;
-        this.agent = agent;
-        this.client = client;
-    }
-    get id() {
-        return this.#metadata.knowledge_set;
-    }
-    get title() {
-        return this.#metadata.conversation.title ?? "";
-    }
-    get status() {
-        return stateToStatus(this.#metadata.conversation.state);
-    }
-    isRunning() {
-        switch (this.status) {
-            case "queued":
-            case "running":
-                return true;
-            default:
-                return false;
-        }
-    }
-    async getMessages({ from = 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: from.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");
-            }
-        });
-    }
-    async refresh() {
-        this.#metadata = await Task.#fetchMetadata(this.id, this.agent.id, this.client);
-    }
-    [exports.resetSubscribeBackoff]() {
-        this.#backoffMs = 1000;
-        this.#delayController?.abort();
-    }
-    subscribe() {
-        if (this.isSubscribed()) {
-            return;
-        }
-        this.#controller = new AbortController();
-        const signal = this.#controller.signal;
-        let currentStatus = this.status;
-        const messagesCursor = new Date(0);
-        const emitted = new Set();
-        let lastMessage = null;
-        const pendingTools = new Map();
-        // Initialize backoff and tracking
-        this.#backoffMs = 1000;
-        this.#lastUpdatedAt = this.#metadata.update_date;
-        void (async () => {
-            while (this.isSubscribed() && !signal.aborted) {
-                try {
-                    const [, result] = await Promise.allSettled([
-                        this.refresh(),
-                        this.getMessages({ from: messagesCursor }),
-                    ]);
-                    if (!this.isSubscribed() || signal.aborted) {
-                        break;
-                    }
-                    const messages = result.status === "fulfilled" ? result.value : [];
-                    // Track if any changes occurred
-                    let hasChanges = false;
-                    // Check for status changes
-                    if (this.status !== currentStatus) {
-                        currentStatus = this.status;
-                        this.dispatchEvent(new event_js_1.TaskStatusEvent(this.status));
-                        hasChanges = true;
-                    }
-                    // Check for metadata update_date changes
-                    if (this.#metadata.update_date !== this.#lastUpdatedAt) {
-                        this.#lastUpdatedAt = this.#metadata.update_date;
-                        hasChanges = true;
-                    }
-                    // Process messages
-                    if (messages.length) {
-                        hasChanges = true;
-                        for (const message of messages) {
-                            if (emitted.has(message.id)) {
-                                switch (message.type) {
-                                    case "agent-error":
-                                    case "agent-message":
-                                    case "user-message":
-                                        // don't re-fire
-                                        continue;
-                                }
-                            }
-                            emitted.add(message.id);
-                            switch (message.type) {
-                                case "agent-error":
-                                    this.dispatchEvent(new event_js_1.TaskErrorEvent(message));
-                                    break;
-                                case "tool-run": {
-                                    const { status } = message;
-                                    if (pendingTools.get(message.id)?.status == status) {
-                                        // no change to the tool status
-                                        continue;
-                                    }
-                                    if (["pending", "running"].includes(status)) {
-                                        pendingTools.set(message.id, message);
-                                    }
-                                    else {
-                                        pendingTools.delete(message.id);
-                                    }
-                                    this.dispatchEvent(new event_js_1.TaskUpdateEvent(message));
-                                    break;
-                                }
-                                case "agent-message":
-                                case "user-message":
-                                    this.dispatchEvent(new event_js_1.TaskMessageEvent(message));
-                            }
-                            lastMessage = message;
-                        }
-                        // +1 the api treats after inclusively
-                        let nextCursor = messages.at(-1).createdAt.getTime() + 1;
-                        // set the cursor as the earliest pending tool
-                        for (const pending of pendingTools.values()) {
-                            if (nextCursor > pending.createdAt.getTime()) {
-                                nextCursor = pending.createdAt.getTime();
-                            }
-                        }
-                        messagesCursor.setTime(nextCursor);
-                    }
-                    // Apply backoff logic
-                    if (hasChanges) {
-                        // Reset backoff on any changes
-                        this.#backoffMs = 1000;
-                    }
-                    else if (!this.isRunning() && lastMessage?.isAgent()) {
-                        // Apply exponential backoff when idle with last message from agent
-                        this.#backoffMs = Math.min(this.#backoffMs * 2, 60000);
-                    }
-                }
-                finally {
-                    // Wait for the backoff period or abort signal
-                    if (!signal.aborted) {
-                        // Create a new controller for this delay that can be aborted independently
-                        this.#delayController = new AbortController();
-                        await Promise.race([
-                            (0, utils_js_1.delay)(this.#backoffMs),
-                            (0, utils_js_1.abortPromise)(AbortSignal.any([
-                                signal,
-                                this.#delayController.signal,
-                            ])),
-                        ]);
-                    }
-                }
-            }
-        })();
-    }
-    isSubscribed() {
-        return this.#controller !== undefined;
-    }
-    unsubscribe() {
-        this.#delayController?.abort();
-        this.#controller?.abort();
-        this.#delayController = undefined;
-        this.#controller = undefined;
-    }
-    addEventListener(type, listener, options) {
-        this.subscribe();
-        const signal = AbortSignal.any([
-            ...(options && typeof options === "object" && options.signal
-                ? [options.signal]
-                : []),
-            this.#controller.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;