@relevanceai/sdk 3.0.2 → 3.1.0

package/script/message/task.d.ts

@@ -4,9 +4,11 @@ import type { ToolMessage } from "./tool.js";
 import type { UserMessage } from "./user.js";
 import type { WorkforceAgentMessage } from "./workforce-agent.js";
 import type { WorkforceAgentHandoverMessage } from "./workforce-agent-handover.js";
-export type AnyTaskMessage = AgentMessage | AgentErrorMessage | ToolMessage | UserMessage | WorkforceAgentMessage | WorkforceAgentHandoverMessage;
+import type { ThinkingMessage } from "./stream.js";
+import type { TypingMessage } from "./stream.js";
+export type AnyTaskMessage = AgentMessage | AgentErrorMessage | ThinkingMessage | TypingMessage | ToolMessage | UserMessage | WorkforceAgentMessage | WorkforceAgentHandoverMessage;
 export type TaskMessageType = AnyTaskMessage["type"];
-interface MessageContent {
+export interface MessageContent {
     type: AnyTaskMessage["type"];
 }
 export interface TaskMessageData<C extends MessageContent = MessageContent> {
@@ -54,10 +56,15 @@ export declare abstract class GenericMessage<C extends MessageContent = MessageC
      */
     isUser(): this is UserMessage;
     /**
-     * Returns if the message was an error sent by the agent.
+     * Returns if the message is agent thinking.
      *
      * @returns {boolean}
      */
-    isAgentError(): this is AgentErrorMessage;
+    isThinking(): this is ThinkingMessage;
+    /**
+     * Returns if the message is agent typing.
+     *
+     * @returns {boolean}
+     */
+    isTyping(): this is TypingMessage;
 }
-export {};

package/script/message/task.js

@@ -55,12 +55,20 @@ class GenericMessage {
         return this.type === "user-message";
     }
     /**
-     * Returns if the message was an error sent by the agent.
+     * Returns if the message is agent thinking.
      *
      * @returns {boolean}
      */
-    isAgentError() {
-        return this.type === "agent-error";
+    isThinking() {
+        return this.type === "agent-thinking";
+    }
+    /**
+     * Returns if the message is agent typing.
+     *
+     * @returns {boolean}
+     */
+    isTyping() {
+        return this.type === "agent-typing";
     }
 }
 exports.GenericMessage = GenericMessage;

package/script/region.d.ts

@@ -3,3 +3,4 @@ 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;
+export declare function regionStreamingURL(region: Region, token: string): string;

package/script/region.js

@@ -2,9 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.REGION_AU = exports.REGION_EU = exports.REGION_US = void 0;
 exports.regionBaseURL = regionBaseURL;
+exports.regionStreamingURL = regionStreamingURL;
 exports.REGION_US = "bcbe5a";
 exports.REGION_EU = "d7b62b";
 exports.REGION_AU = "f1db6c";
 function regionBaseURL(region) {
     return `https://api-${region}.stack.tryrelevance.com`;
 }
+function regionStreamingURL(region, token) {
+    return `https://${region}.streaming.tryrelevance.com/v1/stream?authorization=Bearer+${token}`;
+}

package/script/task/agent-strategy.js

@@ -25,15 +25,22 @@ class AgentStrategy {
         return this.agent;
     }
     async getMetadata() {
-        const { metadata } = await this.client.fetch(`/agents/${this.agent.id}/tasks/${this.id}/metadata`);
+        const url = `/agents/${this.agent.id}/tasks/${this.id}/metadata?include_streaming_token=true`;
+        const res = await this.client.fetch(url);
         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),
+            name: res.metadata.conversation.title,
+            status: (0, agent_js_1.stateToStatus)(res.metadata.conversation.state),
+            createdAt: new Date(res.metadata.insert_date),
+            updatedAt: new Date(res.metadata.update_date),
+            streamingToken: res.streaming_token
+                ? {
+                    token: res.streaming_token.token,
+                    expiresAt: res.streaming_token.expiry_time_ms,
+                }
+                : undefined,
         };
     }
     async getMessages({ after = new Date(0) } = {}) {

package/script/task/stream.d.ts

@@ -0,0 +1,24 @@
+import { Emitter } from "../emitter.js";
+import { type Region } from "../region.js";
+import type { TaskStrategy } from "./task.js";
+export type StreamingToken = {
+    token: string;
+    expiresAt: number;
+};
+export type StreamDetail = {
+    content: string;
+    documentId: string;
+};
+type TaskStreamEventMap = {
+    thinking: StreamDetail;
+    typing: StreamDetail;
+};
+export declare class TaskStream extends Emitter<TaskStreamEventMap> {
+    #private;
+    constructor(strategy: TaskStrategy<any>, metadata: {
+        region: Region;
+        streamingToken: StreamingToken;
+    });
+    close(): void;
+}
+export {};

package/script/task/stream.js

@@ -0,0 +1,155 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskStream = void 0;
+const emitter_js_1 = require("../emitter.js");
+const region_js_1 = require("../region.js");
+class TaskStream extends emitter_js_1.Emitter {
+    #strategy;
+    #region;
+    #token;
+    #closed = false;
+    #refreshTimer = null;
+    #source = null;
+    #fetchController = null;
+    constructor(strategy, metadata) {
+        super();
+        this.#strategy = strategy;
+        this.#region = metadata.region;
+        this.#token = metadata.streamingToken;
+        this.#connect();
+    }
+    close() {
+        this.#closed = true;
+        this.#clearRefreshTimer();
+        this.#disconnect();
+    }
+    #connect() {
+        if (this.#closed)
+            return;
+        this.#scheduleRefresh();
+        if (typeof EventSource !== "undefined") {
+            this.#connectEventSource();
+        }
+        else {
+            this.#connectFetch();
+        }
+    }
+    #disconnect() {
+        this.#clearRefreshTimer();
+        if (this.#source) {
+            this.#source.close();
+            this.#source = null;
+        }
+        if (this.#fetchController) {
+            this.#fetchController.abort();
+            this.#fetchController = null;
+        }
+    }
+    #connectEventSource() {
+        const url = (0, region_js_1.regionStreamingURL)(this.#region, this.#token.token);
+        const source = new EventSource(url);
+        this.#source = source;
+        source.addEventListener("message", (event) => {
+            this.#handleData(event.data);
+        });
+    }
+    #connectFetch() {
+        const url = (0, region_js_1.regionStreamingURL)(this.#region, this.#token.token);
+        const controller = new AbortController();
+        this.#fetchController = controller;
+        void (async () => {
+            try {
+                const response = await fetch(url, {
+                    headers: { Accept: "text/event-stream" },
+                    signal: controller.signal,
+                });
+                if (!response.ok || !response.body)
+                    return;
+                const reader = response.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const { events, remainder } = this.#parseSSE(buffer);
+                    buffer = remainder;
+                    for (const data of events) {
+                        this.#handleData(data);
+                    }
+                }
+            }
+            catch {
+                // aborted or network error — ignore if closed
+            }
+        })();
+    }
+    #parseSSE(buffer) {
+        const events = [];
+        const blocks = buffer.split("\n\n");
+        const remainder = blocks.pop(); // last chunk may be incomplete
+        for (const block of blocks) {
+            for (const line of block.split("\n")) {
+                if (line.startsWith("data:")) {
+                    events.push(line.slice(5).trimStart());
+                }
+            }
+        }
+        return { events, remainder };
+    }
+    #handleData(raw) {
+        try {
+            const data = JSON.parse(raw);
+            switch (data.type) {
+                case "thinking":
+                    this.dispatchEvent(new CustomEvent("thinking", {
+                        detail: { content: data.content, documentId: data.documentId },
+                    }));
+                    break;
+                case "text":
+                    this.dispatchEvent(new CustomEvent("typing", {
+                        detail: { content: data.content, documentId: data.documentId },
+                    }));
+                    break;
+            }
+        }
+        catch {
+            // ignore malformed JSON
+        }
+    }
+    #scheduleRefresh() {
+        this.#clearRefreshTimer();
+        const delay = this.#token.expiresAt - Date.now() - 30_000;
+        if (delay <= 0)
+            return; // already expired or about to
+        this.#refreshTimer = setTimeout(() => this.#refresh(), delay);
+    }
+    #clearRefreshTimer() {
+        if (this.#refreshTimer !== null) {
+            clearTimeout(this.#refreshTimer);
+            this.#refreshTimer = null;
+        }
+    }
+    async #refresh() {
+        if (this.#closed)
+            return;
+        try {
+            const metadata = await this.#strategy.getMetadata();
+            if (this.#closed)
+                return;
+            if (!metadata.streamingToken) {
+                this.close();
+                return;
+            }
+            this.#region = metadata.region;
+            this.#token = metadata.streamingToken;
+            this.#disconnect();
+            this.#connect();
+        }
+        catch {
+            // refresh failed — try again on next schedule
+        }
+    }
+}
+exports.TaskStream = TaskStream;

package/script/task/task.d.ts

@@ -4,7 +4,9 @@ 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";
+import { type StreamingToken } from "./stream.js";
 export type TaskStatus = "not-started" | "idle" | "paused" | "queued" | "running" | "action" | "completed" | "cancelled" | "error";
+export type { StreamingToken };
 export interface TaskMetadata {
     id: string;
     region: Region;
@@ -13,6 +15,7 @@ export interface TaskMetadata {
     name: string;
     createdAt: Date;
     updatedAt: Date;
+    streamingToken?: StreamingToken;
 }
 type TaskEventMap = {
     updated: undefined;
@@ -56,4 +59,3 @@ export declare class Task<S extends Agent | Workforce, E extends TaskEventMap =
         handleEvent: (event: CustomEvent<E[K]>) => void;
     } | null, options?: boolean | AddEventListenerOptions): void;
 }
-export {};

package/script/task/task.js

@@ -4,6 +4,8 @@ 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");
+const stream_js_1 = require("../message/stream.js");
+const stream_js_2 = require("./stream.js");
 exports.resetBackoffDuration = Symbol("resetBackoffDuration");
 const backoffStartingDuration = 1_000;
 const backoffMaxDuration = 60_000;
@@ -13,6 +15,7 @@ class Task extends emitter_js_1.Emitter {
     backoffDuration = 0;
     strategy;
     #metadata;
+    #stream = null;
     constructor(metadata, strategy) {
         super();
         this.strategy = strategy;
@@ -54,6 +57,33 @@ class Task extends emitter_js_1.Emitter {
                 return false;
         }
     }
+    #connectStream() {
+        const stream = new stream_js_2.TaskStream(this.strategy, {
+            region: this.#metadata.region,
+            streamingToken: this.#metadata.streamingToken,
+        });
+        stream.addEventListener("thinking", (event) => {
+            this.dispatchEvent(new event_js_1.TaskMessageEvent(new stream_js_1.ThinkingMessage({
+                item_id: event.detail.documentId,
+                insert_date_: new Date().toISOString(),
+                content: {
+                    type: "agent-thinking",
+                    text: event.detail.content,
+                },
+            })));
+        });
+        stream.addEventListener("typing", (event) => {
+            this.dispatchEvent(new event_js_1.TaskMessageEvent(new stream_js_1.TypingMessage({
+                item_id: event.detail.documentId,
+                insert_date_: new Date().toISOString(),
+                content: {
+                    type: "agent-typing",
+                    text: event.detail.content,
+                },
+            })));
+        });
+        this.#stream = stream;
+    }
     #subscribe() {
         if (this.subscribed) {
             return;
@@ -62,9 +92,12 @@ class Task extends emitter_js_1.Emitter {
         this.subscribed = subscribed; // subscribed ref
         const isSubscribed = () => !subscribed.signal.aborted;
         this.backoffDuration = backoffStartingDuration;
-        const cursor = new Date();
+        const cursor = new Date(this.#metadata.createdAt);
         const emitted = new Set();
         const pending = new Map();
+        if (this.#metadata.streamingToken) {
+            this.#connectStream();
+        }
         void (async () => {
             while (isSubscribed()) {
                 try {
@@ -81,6 +114,9 @@ class Task extends emitter_js_1.Emitter {
                         hasChanges = true;
                     }
                     this.#metadata = metadata;
+                    if (!this.#stream && metadata.streamingToken) {
+                        this.#connectStream();
+                    }
                     if (messages.length) {
                         for (const message of messages) {
                             if (emitted.has(message.id)) {
@@ -107,7 +143,17 @@ class Task extends emitter_js_1.Emitter {
                                     this.dispatchEvent(new event_js_1.TaskMessageEvent(message));
                                     break;
                                 }
-                                case "agent-message":
+                                case "agent-message": {
+                                    if (message.isAgent() && message.isGenerating()) {
+                                        pending.set(message.id, message);
+                                        break;
+                                    }
+                                    emitted.add(message.id);
+                                    pending.delete(message.id);
+                                    hasChanges = true;
+                                    this.dispatchEvent(new event_js_1.TaskMessageEvent(message));
+                                    break;
+                                }
                                 case "user-message":
                                     hasChanges = true;
                                     emitted.add(message.id);
@@ -143,6 +189,8 @@ class Task extends emitter_js_1.Emitter {
         })();
     }
     unsubscribe() {
+        this.#stream?.close();
+        this.#stream = null;
         this.subscribed?.abort();
         this.subscribed = null;
         this.backoff?.abort();

package/script/task/workforce-strategy.js

@@ -81,15 +81,22 @@ class WorkforceStrategy {
         });
     }
     async getMetadata() {
-        const { metadata } = await this.client.fetch(`/workforce/tasks/${this.id}/metadata`);
+        const url = `/workforce/tasks/${this.id}/metadata?include_streaming_token=true`;
+        const res = await this.client.fetch(url);
         return {
             id: this.id,
             region: this.client.region,
             project: this.client.project,
-            name: metadata.title,
-            status: WorkforceStrategy.convertStatus(metadata.state),
-            createdAt: new Date(metadata.insert_date),
-            updatedAt: new Date(metadata.update_date),
+            name: res.metadata.title,
+            status: WorkforceStrategy.convertStatus(res.metadata.state),
+            createdAt: new Date(res.metadata.insert_date),
+            updatedAt: new Date(res.metadata.update_date),
+            streamingToken: res.streaming_token
+                ? {
+                    token: res.streaming_token.token,
+                    expiresAt: res.streaming_token.expiry_time_ms,
+                }
+                : undefined,
         };
     }
 }

package/script/workforce.js

@@ -72,6 +72,7 @@ class Workforce {
                 workforce_id: this.id,
                 workforce_task_id: taskId,
                 trigger: {
+                    use_streaming: true,
                     message: {
                         role: "user",
                         content: message,