@artinet/sdk/dist/services/a2a/messenger.js

A TypeScript SDK for building collaborative AI agents.

import { EventEmitter } from "eventemitter3";
export class Messenger extends EventEmitter {
    _message;
    _messages = [];
    resolvers = [];
    done = false;
    /**
     * @param message - The initial message to send
     * @note The initial message is tied to the messenger and cannot be changed
     */
    constructor(message) {
        super();
        this._message = message;
        this._messages.push(message);
    }
    /**
     * @returns True if the channel is open
     */
    get isOpen() {
        return !this.done;
    }
    /**
     * @returns The list of commands
     */
    get message() {
        return this._messages[0] ?? this._message;
    }
    /**
     * @returns The current message
     */
    get messages() {
        return this._messages;
    }
    /**
     * @returns The command channel as an async iterable
     */
    [Symbol.asyncIterator]() {
        return this;
    }
    valueOf() {
        return this.message;
    }
    async send(message) {
        if (this.done) {
            throw new Error("Messenger is closed");
        }
        const resolver = this.resolvers.shift();
        if (resolver) {
            resolver({ value: message, done: false });
        }
        else {
            this._messages.push(message);
        }
        this.emit("message", message);
    }
    async close() {
        this.done = true;
        this.resolvers.forEach((resolver) => resolver({ value: undefined, done: true }));
        this.resolvers = [];
        this.emit("close");
    }
    async next() {
        if (this._messages.length)
            return Promise.resolve({ value: this._messages.shift(), done: false });
        if (this.done)
            return Promise.resolve({ value: undefined, done: true });
        return new Promise((resolve) => {
            this.resolvers.push(resolve);
        });
    }
    return(value) {
        this.close();
        this._messages = [];
        return Promise.resolve({ value, done: true });
    }
    static create(messageParams) {
        const instance = new Messenger(messageParams);
        return new Proxy(instance, {
            get(target, prop, _) {
                if (prop in target.message) {
                    return target.message[prop];
                }
                else if (prop in target) {
                    return target[prop];
                }
                return undefined;
            },
        });
    }
}