@meshagent/meshagent-agents 0.47.1 → 0.49.0

package/dist/node/chat-client.js

@@ -1,19 +1,40 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatThreadSession = exports.MessagingChatClient = exports.BaseMessagingChatClient = exports.ThreadListSubscribe = exports.ThreadSubscribe = exports.messagingChatThreadListSubscribeType = exports.messagingChatThreadSubscribeType = exports.BaseChatClient = exports.ChatThreadStartResult = exports.ChatThreadSessionLoadState = exports.ChatThreadSessionLoadPhase = exports.PendingAgentInput = exports.AgentMessageEvent = void 0;
+exports.ChatThreadSession = exports.MessagingChatClient = exports.WebSocketChatClient = exports.BaseMessagingChatClient = exports.ThreadListSubscribe = exports.ThreadSubscribe = exports.messagingChatThreadListSubscribeType = exports.messagingChatThreadSubscribeType = exports.BaseChatClient = exports.PendingThreadStartCandidate = exports.ChatThreadStartResult = exports.ChatThreadSessionLoadState = exports.ChatThreadSessionLoadPhase = exports.PendingAgentInput = exports.AgentMessageEvent = void 0;
 const meshagent_1 = require("@meshagent/meshagent");
+const msgpack_1 = require("@msgpack/msgpack");
+const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
 const uuid_1 = require("uuid");
 const agent_messages_js_1 = require("./agent-messages.js");
 const change_emitter_js_1 = require("./change-emitter.js");
 class AgentMessageEvent {
     constructor({ message, createdAt, attachment }) {
-        this.message = message;
-        this.createdAt = createdAt ?? dateOrNull(message.createdAt) ?? new Date();
+        this.listeners = new Set();
+        this.messageValue = message;
+        this.createdAt = createdAt ?? message.createdAtUtc ?? new Date();
         this.attachment = attachment;
     }
+    get message() {
+        return this.messageValue;
+    }
     get payload() {
         return { ...this.message.toJson(), created_at: this.createdAt.toISOString() };
     }
+    addEventListener(listener) {
+        this.listeners.add(listener);
+    }
+    removeEventListener(listener) {
+        this.listeners.delete(listener);
+    }
+    replaceMessage(message) {
+        this.messageValue = message;
+        for (const listener of [...this.listeners]) {
+            listener();
+        }
+    }
 }
 exports.AgentMessageEvent = AgentMessageEvent;
 function agentRoomMessageFromEvent(event) {
@@ -99,6 +120,13 @@ class ChatThreadStartResult {
     }
 }
 exports.ChatThreadStartResult = ChatThreadStartResult;
+class PendingThreadStartCandidate {
+    constructor({ messageId, senderName }) {
+        this.messageId = messageId;
+        this.senderName = senderName;
+    }
+}
+exports.PendingThreadStartCandidate = PendingThreadStartCandidate;
 class EventQueue {
     constructor() {
         this.subscribers = new Set();
@@ -151,12 +179,15 @@ class EventQueue {
     }
 }
 class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
-    constructor() {
-        super(...arguments);
+    constructor({ threadCreatedPendingStartMatcher, deduplicateClientToolRequests = false, } = {}) {
+        super();
         this.sessionsByPath = new Map();
         this.pendingStartRequests = new Map();
         this.pendingSessionEventsByPath = new Map();
         this.eventQueue = new EventQueue();
+        this.claimedClientToolRequests = new Set();
+        this.threadCreatedPendingStartMatcher = threadCreatedPendingStartMatcher;
+        this.deduplicateClientToolRequests = deduplicateClientToolRequests;
     }
     get events() {
         return this.eventQueue.stream;
@@ -178,14 +209,41 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
     localParticipantId() {
         return undefined;
     }
-    isClientToolCallForLocalParticipant(request) {
-        const targetParticipantId = request.targetParticipantId?.trim();
-        return targetParticipantId == null || targetParticipantId === "" || targetParticipantId === this.localParticipantId();
+    clientToolRequestKey(threadPath, requestId) {
+        const normalizedThreadPath = threadPath.trim();
+        const normalizedRequestId = requestId.trim();
+        if (normalizedThreadPath === "" || normalizedRequestId === "") {
+            return undefined;
+        }
+        return `${normalizedThreadPath}\n${normalizedRequestId}`;
+    }
+    claimClientToolRequest(threadPath, requestId) {
+        if (!this.deduplicateClientToolRequests) {
+            return true;
+        }
+        const key = this.clientToolRequestKey(threadPath, requestId);
+        if (key == null) {
+            return true;
+        }
+        if (this.claimedClientToolRequests.has(key)) {
+            return false;
+        }
+        this.claimedClientToolRequests.add(key);
+        return true;
+    }
+    finishClientToolRequest(threadPath, requestId, { responseSent }) {
+        if (!this.deduplicateClientToolRequests || responseSent) {
+            return;
+        }
+        const key = this.clientToolRequestKey(threadPath, requestId);
+        if (key != null) {
+            this.claimedClientToolRequests.delete(key);
+        }
     }
     cleanParticipantName(value) {
         return nonEmptyTrimmed(value);
     }
-    openThread(threadPath, { load = true, sinceTurn, reloadIfOpen = false, drainPendingEvents = true, } = {}) {
+    openThread(threadPath, { load = true, sinceTurn, reloadIfOpen = false, } = {}) {
         const normalized = threadPath.trim();
         if (normalized === "") {
             throw new TypeError("thread path cannot be empty");
@@ -197,11 +255,8 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             }
             return existing;
         }
-        const created = new ChatThreadSession({ client: this, threadPath: normalized });
+        const created = ChatThreadSession.create({ client: this, threadPath: normalized });
         this.sessionsByPath.set(normalized, created);
-        if (drainPendingEvents) {
-            this.drainPendingSessionEvents(normalized, created);
-        }
         this.openSession(created, { load, sinceTurn });
         this.notifyListeners();
         return created;
@@ -211,7 +266,7 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             this.notifyListeners();
         });
     }
-    async startThread({ messageId, message, attachments, name, backend, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, toolChoice, omitContent = false, }) {
+    async startThread({ messageId, message, attachments, name, backend, provider, model, voice, outputModalities, realtimeProtocol, senderName, clientToolkits, omitContent = false, }) {
         const resolvedMessageId = messageId == null || messageId.trim() === "" ? (0, uuid_1.v4)() : messageId.trim();
         const resolvedSenderName = this.cleanParticipantName(senderName) ?? this.localParticipantName();
         const payload = new agent_messages_js_1.StartThread({
@@ -226,10 +281,9 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             realtimeProtocol: nonEmptyTrimmed(realtimeProtocol),
             senderName: resolvedSenderName,
             clientToolkits: clientToolkits != null && clientToolkits.length > 0 ? clientToolkits : undefined,
-            toolChoice: toolChoice?.toJson(),
         });
         const completer = new meshagent_1.Completer();
-        this.pendingStartRequests.set(resolvedMessageId, completer);
+        this.pendingStartRequests.set(resolvedMessageId, { request: payload, completer });
         try {
             await this.sendAgentMessage(payload);
             const response = await completer.fut;
@@ -239,18 +293,18 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             if (threadPath === "") {
                 throw new Error("Agent did not return a thread_id for the new thread.");
             }
-            const session = this.openThread(threadPath, { load: false, drainPendingEvents: false });
+            const session = this.openThread(threadPath, { load: false });
             if (!omitContent) {
                 session.addAgentMessage(new AgentMessageEvent({
                     message: this.resolvedStartThreadMessage({ payload, threadPath }),
-                    createdAt: dateOrNull(payload.createdAt) ?? undefined,
+                    createdAt: payload.createdAtUtc,
                 }));
             }
             this.drainPendingSessionEvents(threadPath, session);
             return new ChatThreadStartResult({
                 session,
                 threadPath,
-                realtimeConnection: response.type === agent_messages_js_1.agentThreadStartedType && response.realtimeConnection != null
+                realtimeConnection: response instanceof agent_messages_js_1.ThreadStarted && response.realtimeConnection != null
                     ? response.realtimeConnection.toJson()
                     : undefined,
             });
@@ -274,6 +328,7 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             mcp: payload.mcp,
             clientToolkits: payload.clientToolkits,
             toolkits: payload.toolkits,
+            toolChoice: payload.toolChoice,
         });
     }
     drainPendingSessionEvents(threadPath, session) {
@@ -287,9 +342,13 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
         }
     }
     handleAgentMessage(message, { createdAt, attachment } = {}) {
-        if (message instanceof agent_messages_js_1.AgentClientToolCallRequested &&
-            !this.isClientToolCallForLocalParticipant(message)) {
-            return;
+        if (message instanceof agent_messages_js_1.AgentClientToolCallRequested) {
+            const targetParticipantId = message.targetParticipantId?.trim();
+            if (targetParticipantId != null &&
+                targetParticipantId !== "" &&
+                targetParticipantId !== this.localParticipantId()) {
+                return;
+            }
         }
         if (message.type === agent_messages_js_1.agentConnectionStatusType) {
             this._connectionStatus = message;
@@ -300,10 +359,13 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
             sourceMessageId != null &&
             sourceMessageId.trim() !== "") {
             const pending = this.pendingStartRequests.get(sourceMessageId.trim());
-            if (pending != null && !pending.completed) {
-                pending.complete(message);
+            if (pending != null && !pending.completer.completed) {
+                pending.completer.complete(message);
             }
         }
+        if (message instanceof agent_messages_js_1.ThreadCreated) {
+            this.acknowledgePendingStartFromThreadCreated(message);
+        }
         const threadPath = "threadId" in message ? String(message.threadId).trim() : "";
         if (threadPath === "") {
             this.notifyListeners();
@@ -321,6 +383,40 @@ class BaseChatClient extends change_emitter_js_1.ChangeEmitter {
         }
         this.notifyListeners();
     }
+    acknowledgePendingStartFromThreadCreated(message) {
+        const matcher = this.threadCreatedPendingStartMatcher;
+        const threadPath = String(message.thread?.path ?? "").trim();
+        if (matcher == null || threadPath === "") {
+            return;
+        }
+        const candidates = [...this.pendingStartRequests.entries()]
+            .filter(([, pending]) => !pending.completer.completed)
+            .map(([messageId, pending]) => new PendingThreadStartCandidate({
+            messageId,
+            senderName: pending.request.senderName,
+        }));
+        if (candidates.length === 0) {
+            return;
+        }
+        let matchedMessageId;
+        try {
+            matchedMessageId = matcher(message, candidates)?.trim();
+        }
+        catch {
+            return;
+        }
+        if (matchedMessageId == null || matchedMessageId === "") {
+            return;
+        }
+        const pending = this.pendingStartRequests.get(matchedMessageId);
+        if (pending == null || pending.completer.completed) {
+            return;
+        }
+        pending.completer.complete(new agent_messages_js_1.ThreadStarted({
+            sourceMessageId: matchedMessageId,
+            threadId: threadPath,
+        }));
+    }
     emitConnectionStatus({ status, message, reason, retryDelay, }) {
         const event = new agent_messages_js_1.AgentConnectionStatus({
             status,
@@ -377,9 +473,17 @@ class ThreadListSubscribe {
     }
 }
 exports.ThreadListSubscribe = ThreadListSubscribe;
+function participantWaitAbortedError(reason) {
+    if (reason instanceof Error) {
+        return reason;
+    }
+    const error = new Error("Agent participant wait was cancelled.");
+    error.name = "AbortError";
+    return error;
+}
 class BaseMessagingChatClient extends BaseChatClient {
-    constructor({ room, agentName }) {
-        super();
+    constructor({ room, agentName, threadCreatedPendingStartMatcher, deduplicateClientToolRequests = true, }) {
+        super({ threadCreatedPendingStartMatcher, deduplicateClientToolRequests });
         this.pendingParticipantWaits = new Map();
         this.started = false;
         this.hasConnected = false;
@@ -476,7 +580,7 @@ class BaseMessagingChatClient extends BaseChatClient {
         this.attachMessagingListeners();
         this.room.messaging.start();
         this.startRoomStatusListener();
-        await this.room.messaging.enable();
+        this.room.messaging.enable();
         this.waitingForParticipant = true;
         this.onMessagingChanged();
     }
@@ -527,7 +631,13 @@ class BaseMessagingChatClient extends BaseChatClient {
         }
         return null;
     }
-    async waitForAgentParticipant({ waitKey } = {}) {
+    async waitForAgentParticipant({ waitKey, signal, timeoutMs, } = {}) {
+        if (signal?.aborted) {
+            throw participantWaitAbortedError(signal.reason);
+        }
+        if (timeoutMs != null && (!Number.isFinite(timeoutMs) || timeoutMs < 0)) {
+            throw new RangeError("Agent participant wait timeout must be a non-negative finite number.");
+        }
         const existing = this.agentParticipant();
         if (existing != null) {
             return existing;
@@ -535,12 +645,34 @@ class BaseMessagingChatClient extends BaseChatClient {
         const key = waitKey == null || waitKey.trim() === "" ? (0, uuid_1.v4)() : waitKey.trim();
         const completer = new meshagent_1.Completer();
         this.pendingParticipantWaits.set(key, completer);
+        const handleAbort = () => {
+            if (!completer.completed) {
+                completer.completeError(participantWaitAbortedError(signal?.reason));
+            }
+        };
+        signal?.addEventListener("abort", handleAbort, { once: true });
+        if (signal?.aborted) {
+            handleAbort();
+        }
+        const timeout = timeoutMs == null
+            ? undefined
+            : setTimeout(() => {
+                if (!completer.completed) {
+                    completer.completeError(new Error(`Agent messaging participant was not available within ${timeoutMs}ms.`));
+                }
+            }, timeoutMs);
         this.onMessagingChanged();
         try {
             return await completer.fut;
         }
         finally {
-            this.pendingParticipantWaits.delete(key);
+            signal?.removeEventListener("abort", handleAbort);
+            if (timeout != null) {
+                clearTimeout(timeout);
+            }
+            if (this.pendingParticipantWaits.get(key) === completer) {
+                this.pendingParticipantWaits.delete(key);
+            }
         }
     }
     async sendAgentMessage(message, { attachment } = {}) {
@@ -595,6 +727,255 @@ class BaseMessagingChatClient extends BaseChatClient {
     }
 }
 exports.BaseMessagingChatClient = BaseMessagingChatClient;
+class WebSocketChatClient extends BaseChatClient {
+    constructor({ url, token, participantName, protocols = ["meshagent-msgpack"], reconnect = true, reconnectInitialDelay = 1000, reconnectMaxDelay = 10000, }) {
+        super({ deduplicateClientToolRequests: true });
+        this.started = false;
+        this.stopping = false;
+        this.connecting = false;
+        this.reconnectAttempts = 0;
+        this.onMessage = (event) => {
+            try {
+                const bytes = webSocketMessageBytes(event.data);
+                if (bytes == null) {
+                    return;
+                }
+                const decoded = (0, msgpack_1.decode)(bytes);
+                if (!isJsonMap(decoded)) {
+                    throw new Error("chat websocket received a non-object message");
+                }
+                const message = agent_messages_js_1.AgentMessage.fromJson(decoded);
+                if (message instanceof agent_messages_js_1.AgentConnectionStatus) {
+                    const participantId = message.participantId?.trim();
+                    if (participantId != null && participantId !== "") {
+                        this.assignedParticipantId = participantId;
+                    }
+                }
+                this.handleAgentMessage(message);
+            }
+            catch (error) {
+                this.receiveError = error;
+                this.emitConnectionStatus({
+                    status: "disconnected",
+                    message: "Chat websocket message could not be decoded",
+                    reason: describeError(error),
+                });
+                this.webSocket?.close(1003);
+            }
+        };
+        this.onSocketError = (event) => {
+            this.receiveError = event.error ?? new Error("chat websocket error");
+        };
+        this.onSocketClose = (event) => {
+            const webSocket = this.webSocket;
+            if (webSocket == null) {
+                return;
+            }
+            this.closeCode = event.code;
+            this.closeReason = event.reason;
+            this.detachSocketListeners(webSocket);
+            this.webSocket = undefined;
+            this.assignedParticipantId = undefined;
+            if (this.stopping || !this.started) {
+                this.notifyListeners();
+                return;
+            }
+            const reason = event.reason !== "" ? `code=${event.code}: ${event.reason}` : `code=${event.code}`;
+            if (this.reconnect) {
+                this.scheduleReconnect({ reason });
+            }
+            else {
+                this.emitConnectionStatus({
+                    status: "disconnected",
+                    message: "Chat websocket disconnected",
+                    reason,
+                });
+            }
+            this.notifyListeners();
+        };
+        this.url = url;
+        this.token = token;
+        this.participantName = participantName;
+        this.protocols = protocols;
+        this.reconnect = reconnect;
+        this.reconnectInitialDelay = reconnectInitialDelay;
+        this.reconnectMaxDelay = reconnectMaxDelay;
+    }
+    get isConnected() {
+        return this.webSocket != null && this.webSocket.readyState === isomorphic_ws_1.default.OPEN;
+    }
+    localParticipantName() {
+        return this.cleanParticipantName(this.participantName);
+    }
+    localParticipantId() {
+        return this.assignedParticipantId;
+    }
+    async start() {
+        this.started = true;
+        this.stopping = false;
+        if (this.webSocket != null || this.connecting) {
+            return;
+        }
+        await this.connect({ isReconnect: false });
+    }
+    async connect({ isReconnect }) {
+        if (this.webSocket != null || this.connecting || !this.started || this.stopping) {
+            return;
+        }
+        this.connecting = true;
+        const webSocket = new isomorphic_ws_1.default(this.url.toString(), this.resolvedProtocols());
+        this.webSocket = webSocket;
+        this.assignedParticipantId = undefined;
+        webSocket.binaryType = "arraybuffer";
+        try {
+            await new Promise((resolve, reject) => {
+                const onOpen = () => {
+                    cleanup();
+                    resolve();
+                };
+                const onError = (event) => {
+                    cleanup();
+                    reject(event.error ?? new Error("chat websocket connection failed"));
+                };
+                const cleanup = () => {
+                    webSocket.removeEventListener("open", onOpen);
+                    webSocket.removeEventListener("error", onError);
+                };
+                webSocket.addEventListener("open", onOpen);
+                webSocket.addEventListener("error", onError);
+            });
+        }
+        catch (error) {
+            if (this.webSocket === webSocket) {
+                this.webSocket = undefined;
+            }
+            this.receiveError = error;
+            this.connecting = false;
+            if (isReconnect && this.reconnect && !this.stopping) {
+                this.scheduleReconnect({ reason: describeError(error) });
+                return;
+            }
+            this.emitConnectionStatus({
+                status: "disconnected",
+                message: "Chat websocket connection failed",
+                reason: describeError(error),
+            });
+            throw error;
+        }
+        webSocket.addEventListener("message", this.onMessage);
+        webSocket.addEventListener("error", this.onSocketError);
+        webSocket.addEventListener("close", this.onSocketClose);
+        this.connecting = false;
+        this.receiveError = undefined;
+        this.closeCode = undefined;
+        this.closeReason = undefined;
+        const status = isReconnect ? "reconnected" : "connected";
+        this.emitConnectionStatus({
+            status,
+            message: isReconnect ? "Chat websocket reconnected" : "Chat websocket connected",
+        });
+        if (isReconnect) {
+            await this.reopenOpenSessions();
+        }
+        this.reconnectAttempts = 0;
+        this.notifyListeners();
+    }
+    async stop() {
+        this.started = false;
+        this.stopping = true;
+        if (this.reconnectTimer != null) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        const webSocket = this.webSocket;
+        this.webSocket = undefined;
+        this.assignedParticipantId = undefined;
+        if (webSocket != null) {
+            this.detachSocketListeners(webSocket);
+            webSocket.close(1000);
+        }
+        this.emitConnectionStatus({
+            status: "disconnected",
+            message: "Chat websocket disconnected",
+            reason: "client_stopped",
+        });
+        this.stopping = false;
+        this.notifyListeners();
+    }
+    async sendAgentMessage(message, { attachment } = {}) {
+        if (attachment != null) {
+            throw new Error("WebSocketChatClient does not support binary attachments yet.");
+        }
+        const webSocket = this.webSocket;
+        if (webSocket == null || webSocket.readyState !== isomorphic_ws_1.default.OPEN) {
+            throw new Error(this.closedMessage());
+        }
+        webSocket.send((0, msgpack_1.encode)(message.toJson()));
+    }
+    detachSocketListeners(webSocket) {
+        webSocket.removeEventListener("message", this.onMessage);
+        webSocket.removeEventListener("error", this.onSocketError);
+        webSocket.removeEventListener("close", this.onSocketClose);
+    }
+    scheduleReconnect({ reason }) {
+        if (this.reconnectTimer != null || this.stopping || !this.started) {
+            return;
+        }
+        const retryDelay = this.nextReconnectDelay();
+        this.emitConnectionStatus({
+            status: "reconnecting",
+            message: "Chat websocket disconnected; reconnecting",
+            reason,
+            retryDelay,
+        });
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            void this.connect({ isReconnect: true });
+        }, retryDelay);
+    }
+    nextReconnectDelay() {
+        const initialDelay = Math.max(1, this.reconnectInitialDelay);
+        const maxDelay = Math.max(initialDelay, this.reconnectMaxDelay);
+        const factor = 2 ** Math.min(this.reconnectAttempts, 6);
+        this.reconnectAttempts += 1;
+        return Math.min(initialDelay * factor, maxDelay);
+    }
+    async reopenOpenSessions() {
+        for (const session of this.sessions) {
+            if (!session.isOpen) {
+                continue;
+            }
+            await session.open({ load: true, sinceTurn: session.lastCompletedTurnId });
+        }
+    }
+    resolvedProtocols() {
+        const resolved = [];
+        for (const protocol of this.protocols) {
+            const normalized = protocol.trim();
+            if (normalized !== "" && !resolved.includes(normalized)) {
+                resolved.push(normalized);
+            }
+        }
+        const normalizedToken = this.token.trim();
+        if (normalizedToken !== "") {
+            resolved.push(`meshagent-agent.${normalizedToken}`);
+        }
+        return resolved;
+    }
+    closedMessage() {
+        if (this.receiveError != null) {
+            return `chat websocket is closed: ${describeError(this.receiveError)}`;
+        }
+        if (this.closeCode != null) {
+            return `chat websocket is closed (code=${this.closeCode})`;
+        }
+        if (this.closeReason != null && this.closeReason.trim() !== "") {
+            return `chat websocket is closed: ${this.closeReason}`;
+        }
+        return "chat websocket is closed";
+    }
+}
+exports.WebSocketChatClient = WebSocketChatClient;
 class MessagingChatClient extends BaseMessagingChatClient {
     constructor() {
         super(...arguments);
@@ -658,7 +1039,7 @@ class MessagingChatClient extends BaseMessagingChatClient {
             await super.sendAgentMessage(message, { attachment });
             return;
         }
-        if (message.type === agent_messages_js_1.agentThreadOpenType) {
+        if (message instanceof agent_messages_js_1.OpenThread) {
             const previous = this.threadSubscriptions.get(message.threadId);
             if (previous != null) {
                 await previous.close();
@@ -674,7 +1055,7 @@ class MessagingChatClient extends BaseMessagingChatClient {
             this.trackStream(subscription);
             return;
         }
-        if (message.type === agent_messages_js_1.agentThreadCloseType) {
+        if (message instanceof agent_messages_js_1.CloseThread) {
             const subscription = this.threadSubscriptions.get(message.threadId);
             if (subscription != null) {
                 this.threadSubscriptions.delete(message.threadId);
@@ -682,7 +1063,7 @@ class MessagingChatClient extends BaseMessagingChatClient {
                 return;
             }
         }
-        if (message.type === agent_messages_js_1.agentThreadWatchType) {
+        if (message instanceof agent_messages_js_1.WatchThreads) {
             await this.threadListSubscription?.close();
             const stream = await this.room.messaging.stream({
                 to: participant,
@@ -695,7 +1076,7 @@ class MessagingChatClient extends BaseMessagingChatClient {
             this.trackStream(subscription);
             return;
         }
-        if (message.type === agent_messages_js_1.agentThreadUnwatchType && this.threadListSubscription != null) {
+        if (message instanceof agent_messages_js_1.UnwatchThreads && this.threadListSubscription != null) {
             const subscription = this.threadListSubscription;
             this.threadListSubscription = undefined;
             await subscription.close();
@@ -734,6 +1115,9 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
         this.client = client;
         this.threadPath = threadPath;
     }
+    static create({ client, threadPath }) {
+        return new ChatThreadSession({ client, threadPath });
+    }
     get messages() {
         return [...this._messages];
     }
@@ -752,18 +1136,6 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
     get lastCompletedTurnId() {
         return this.lastCompletedTurnIdValue;
     }
-    get activeTurnId() {
-        return this.activeTurnIdValue;
-    }
-    get threadStatus() {
-        return this.threadStatusValue;
-    }
-    get currentModel() {
-        return this.currentModelValue;
-    }
-    get modelsResponse() {
-        return this.modelsResponseValue;
-    }
     async open({ load = true, sinceTurn } = {}) {
         if (this.openState) {
             if (load) {
@@ -778,7 +1150,6 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
                 }
                 catch (error) {
                     this.setLoadState(this.failedLoadState(error));
-                    throw error;
                 }
             }
             return;
@@ -797,7 +1168,6 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
         }
         catch (error) {
             this.setLoadState(this.failedLoadState(error));
-            throw error;
         }
     }
     resetReplayState() {
@@ -844,16 +1214,20 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             response,
         }));
     }
-    async sendText({ messageId, text, attachments, steer = false, turnId, backend, provider, model, voice, outputModalities, senderName, clientToolkits, toolChoice, }) {
+    claimClientToolCall(requestId) {
+        return this.client.claimClientToolRequest(this.threadPath, requestId);
+    }
+    finishClientToolCall(requestId, { responseSent }) {
+        this.client.finishClientToolRequest(this.threadPath, requestId, { responseSent });
+    }
+    injectMessages(messages) {
+        return this.client.sendAgentMessage(new agent_messages_js_1.InjectMessages({
+            threadId: this.threadPath,
+            messages: [...messages],
+        }));
+    }
+    async sendText({ messageId, text, attachments, steer = false, turnId, backend, provider, model, voice, outputModalities, senderName, clientToolkits, }) {
         const resolvedMessageId = messageId == null || messageId.trim() === "" ? (0, uuid_1.v4)() : messageId.trim();
-        const currentModel = this.currentModelValue;
-        const resolvedBackend = nonEmptyTrimmed(backend) ?? currentModel?.backend;
-        const resolvedProvider = nonEmptyTrimmed(provider) ?? currentModel?.provider;
-        const resolvedModel = nonEmptyTrimmed(model) ?? currentModel?.model;
-        const resolvedVoice = nonEmptyTrimmed(voice) ?? currentModel?.voice;
-        const resolvedOutputModalities = outputModalities != null && outputModalities.length > 0
-            ? outputModalities
-            : currentModel?.outputModalities;
         const payload = steer
             ? new agent_messages_js_1.TurnSteer({
                 threadId: this.threadPath,
@@ -867,13 +1241,12 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
                 messageId: resolvedMessageId,
                 senderName: nonEmptyTrimmed(senderName),
                 content: (0, agent_messages_js_1.agentInputContent)({ text, attachments }),
-                backend: resolvedBackend,
-                provider: resolvedProvider,
-                model: resolvedModel,
-                voice: resolvedVoice,
-                outputModalities: resolvedOutputModalities,
+                backend: nonEmptyTrimmed(backend),
+                provider: nonEmptyTrimmed(provider),
+                model: nonEmptyTrimmed(model),
+                voice: nonEmptyTrimmed(voice),
+                outputModalities: outputModalities != null && outputModalities.length > 0 ? outputModalities : undefined,
                 clientToolkits: clientToolkits != null && clientToolkits.length > 0 ? clientToolkits : undefined,
-                toolChoice: toolChoice?.toJson(),
             });
         this.localAgentMessageIds.add(resolvedMessageId);
         this.pendingLocalInputMessageIds.add(resolvedMessageId);
@@ -892,10 +1265,10 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
         await this.client.sendAgentMessage(new agent_messages_js_1.AgentRealtimeAudioChunk({
             threadId: this.threadPath,
             messageId: (0, uuid_1.v4)(),
-            format,
+            format: new agent_messages_js_1.AgentAudioFormat(format),
         }), { attachment: chunk });
     }
-    async commitRealtimeAudio({ turnId, provider, model, voice, outputModalities, }) {
+    async commitRealtimeAudio({ turnId, backend, provider, model, voice, outputModalities, }) {
         const messageId = (0, uuid_1.v4)();
         await this.client.sendAgentMessage(new agent_messages_js_1.AgentRealtimeAudioCommit({
             threadId: this.threadPath,
@@ -906,6 +1279,7 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             threadId: this.threadPath,
             messageId: (0, uuid_1.v4)(),
             turnId,
+            backend: nonEmptyTrimmed(backend),
             provider: nonEmptyTrimmed(provider),
             model: nonEmptyTrimmed(model),
             voice: nonEmptyTrimmed(voice),
@@ -934,56 +1308,9 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             const turnId = normalizedString(threadMessageValue(message, "turnId"));
             if (turnId != null) {
                 this.lastCompletedTurnIdValue = turnId;
-                if (this.activeTurnIdValue === turnId) {
-                    this.activeTurnIdValue = undefined;
-                }
-            }
-            const statusTurnId = normalizedString(this.threadStatusValue?.turnId);
-            if (statusTurnId == null || statusTurnId === turnId) {
-                this.threadStatusValue = undefined;
             }
-            return;
-        }
-        if (message.type === agent_messages_js_1.agentTurnStartAcceptedType || message.type === agent_messages_js_1.agentTurnStartedType) {
-            const turnId = normalizedString(threadMessageValue(message, "turnId"));
-            if (turnId != null) {
-                this.activeTurnIdValue = turnId;
-            }
-            if (message.type === agent_messages_js_1.agentTurnStartedType) {
-                const statusTurnId = normalizedString(this.threadStatusValue?.turnId);
-                if (statusTurnId == null || statusTurnId === turnId) {
-                    this.threadStatusValue = undefined;
-                }
-            }
-            return;
-        }
-        if (message.type === agent_messages_js_1.agentThreadStatusType && message instanceof agent_messages_js_1.AgentThreadStatus) {
-            const mode = normalizedString(message.mode);
-            const status = normalizedString(message.status);
-            const turnId = normalizedString(message.turnId);
-            if (status == null) {
-                this.threadStatusValue = undefined;
-                if (turnId != null && this.activeTurnIdValue === turnId) {
-                    this.activeTurnIdValue = undefined;
-                }
-                return;
-            }
-            this.threadStatusValue = message;
-            if (mode === "steerable" && turnId != null) {
-                this.activeTurnIdValue = turnId;
-            }
-            return;
         }
-        if (message.type === agent_messages_js_1.agentModelChangedType && message instanceof agent_messages_js_1.AgentModelChanged) {
-            this.currentModelValue = message;
-            return;
-        }
-        if (message.type === agent_messages_js_1.agentModelsResponseType && message instanceof agent_messages_js_1.ModelsResponse) {
-            this.modelsResponseValue = message;
-            this.applyActiveModel(message);
-            return;
-        }
-        if (message.type === agent_messages_js_1.agentThreadLoadedType) {
+        else if (message.type === agent_messages_js_1.agentThreadLoadedType) {
             this.setLoadState(new ChatThreadSessionLoadState({
                 phase: ChatThreadSessionLoadPhase.Loaded,
                 startedAt: this.loadStateValue.startedAt,
@@ -1061,45 +1388,21 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
     }
     appendRenderableMessage(event) {
         const message = event.message;
-        if (message.type === agent_messages_js_1.agentTurnEndedType) {
-            if (message.error != null) {
-                this.appendMessage(event);
-            }
-            return;
-        }
-        if (message.type === agent_messages_js_1.agentToolCallEndedType) {
-            const itemId = message.error == null ? undefined : normalizedString(message.itemId);
-            if (itemId != null) {
-                this.upsertItemMessage(`tool_call:${itemId}`, event);
-            }
-            else if (message.error != null) {
-                this.appendMessage(event);
-            }
-            return;
-        }
-        if (message.type === agent_messages_js_1.agentToolCallPendingType || message.type === agent_messages_js_1.agentToolCallInProgressType || message.type === agent_messages_js_1.agentToolCallStartedType) {
-            const itemId = normalizedString(message.itemId);
-            if (itemId != null) {
-                this.upsertItemMessage(`tool_call:${itemId}`, event);
-            }
-            return;
-        }
-        if (message.type === agent_messages_js_1.agentSecretRequestedType) {
+        if (message instanceof agent_messages_js_1.TurnEnded) {
             this.appendMessage(event);
             return;
         }
-        if (message.type === agent_messages_js_1.agentModelChangedType) {
-            this.appendMessage(event);
-            return;
-        }
-        if (message.type === agent_messages_js_1.agentThreadStartType || message.type === agent_messages_js_1.agentTurnStartType || message.type === agent_messages_js_1.agentTurnSteerType) {
-            if (agentInputText(message.content).trim() !== "") {
+        if (message instanceof agent_messages_js_1.StartThread || message instanceof agent_messages_js_1.TurnStart || message instanceof agent_messages_js_1.TurnSteer) {
+            if (agentInputText(messageValue(message, "content")).trim() !== "") {
                 this.appendMessage(event);
+                const messageId = normalizedString(message.messageId);
+                if (messageId != null)
+                    this.pendingLocalInputMessageIds.add(messageId);
             }
             return;
         }
-        if (message.type === agent_messages_js_1.agentTurnStartAcceptedType || message.type === agent_messages_js_1.agentTurnSteerAcceptedType) {
-            const sourceMessageId = normalizedString(sourceMessageIdFor(message));
+        if (message instanceof agent_messages_js_1.TurnStartAccepted) {
+            const sourceMessageId = normalizedString(message.sourceMessageId);
             if (sourceMessageId != null && this.localAgentMessageIds.has(sourceMessageId)) {
                 this.pendingLocalInputMessageIds.delete(sourceMessageId);
                 return;
@@ -1107,36 +1410,21 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             if (agentInputText(message.content).trim() !== "") {
                 this.appendMessage(event, { beforePendingLocalInputs: true });
             }
-            else {
-                this.appendMessage(event);
-            }
-            return;
-        }
-        if (message.type === agent_messages_js_1.agentTurnStartedType ||
-            message.type === agent_messages_js_1.agentTurnSteeredType ||
-            message.type === agent_messages_js_1.agentTurnStartRejectedType ||
-            message.type === agent_messages_js_1.agentTurnSteerRejectedType ||
-            message.type === agent_messages_js_1.agentTurnInterruptAcceptedType ||
-            message.type === agent_messages_js_1.agentTurnInterruptedType) {
-            this.appendMessage(event);
             return;
         }
         if (isMergeableDelta(message)) {
             this.appendOrMergeDelta(event);
             return;
         }
-        if (message.type === agent_messages_js_1.agentImageGenerationPartialType || message.type === agent_messages_js_1.agentImageGenerationCompletedType) {
-            const itemId = normalizedString(message.itemId);
-            if (itemId != null) {
-                this.upsertItemMessage(`image_generation:${itemId}`, event);
-            }
+        if (message instanceof agent_messages_js_1.AgentImageGenerationPartial || message instanceof agent_messages_js_1.AgentImageGenerationCompleted) {
+            this.appendMessage(event);
             return;
         }
-        if (message.type === agent_messages_js_1.agentUsageUpdatedType) {
+        if (message instanceof agent_messages_js_1.AgentClientToolCallRequested) {
             this.appendMessage(event);
             return;
         }
-        if (message instanceof agent_messages_js_1.AgentClientToolCallRequested) {
+        if (message instanceof agent_messages_js_1.AgentConnectionStatus || message instanceof agent_messages_js_1.AgentThreadMessage) {
             this.appendMessage(event);
         }
     }
@@ -1156,15 +1444,6 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
         this.messageIndexes.set(normalizedMessageId, this._messages.length);
         this._messages.push(event);
     }
-    upsertItemMessage(key, event) {
-        const existingIndex = this.messageIndexes.get(key);
-        if (existingIndex == null) {
-            this.messageIndexes.set(key, this._messages.length);
-            this._messages.push(event);
-            return;
-        }
-        this._messages[existingIndex] = event;
-    }
     appendOrMergeDelta(event) {
         const message = event.message;
         const normalizedMessageId = normalizedString(message.messageId);
@@ -1174,7 +1453,7 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             }
             this.mergedDeltaMessageIds.add(normalizedMessageId);
         }
-        const itemId = normalizedString(message.itemId);
+        const itemId = normalizedString(messageValue(message, "itemId"));
         if (itemId == null) {
             return;
         }
@@ -1188,7 +1467,7 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
         const existing = this._messages[existingIndex].message;
         const merged = mergeDeltaMessage(existing, message);
         if (merged != null) {
-            this._messages[existingIndex] = new AgentMessageEvent({ message: merged, createdAt: event.createdAt, attachment: event.attachment });
+            this._messages[existingIndex].replaceMessage(merged);
         }
     }
     indexMessagesFrom(start) {
@@ -1199,29 +1478,6 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
             }
         }
     }
-    applyActiveModel(response) {
-        for (const provider of response.providers) {
-            for (const model of provider.models) {
-                if (!model.active) {
-                    continue;
-                }
-                this.currentModelValue = new agent_messages_js_1.AgentModelChanged({
-                    threadId: this.threadPath,
-                    sourceMessageId: response.sourceMessageId,
-                    backend: provider.backend,
-                    provider: provider.name,
-                    model: model.name,
-                    voice: model.defaultOutputVoice,
-                    inputFormat: model.inputFormat,
-                    outputFormat: model.outputFormat,
-                    turnDetection: model.turnDetection,
-                    realtimeProtocols: model.realtimeProtocols,
-                    outputModalities: model.modalities.length > 0 ? [model.modalities[0]] : ["text"],
-                });
-                return;
-            }
-        }
-    }
     markClosed({ notify = true } = {}) {
         this.openState = false;
         this.loadStateValue = new ChatThreadSessionLoadState({
@@ -1281,12 +1537,33 @@ class ChatThreadSession extends change_emitter_js_1.ChangeEmitter {
     }
 }
 exports.ChatThreadSession = ChatThreadSession;
+function webSocketMessageBytes(value) {
+    if (value instanceof Uint8Array) {
+        return value;
+    }
+    if (value instanceof ArrayBuffer) {
+        return new Uint8Array(value);
+    }
+    if (ArrayBuffer.isView(value)) {
+        return new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+    }
+    return undefined;
+}
+function isJsonMap(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function describeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
 function sourceMessageIdFor(message) {
     const value = "sourceMessageId" in message ? message.sourceMessageId : undefined;
     return typeof value === "string" ? value : undefined;
 }
+function messageValue(message, key) {
+    return message[key];
+}
 function threadMessageValue(message, key) {
-    const value = message[key];
+    const value = messageValue(message, key);
     return typeof value === "string" ? value : undefined;
 }
 function agentInputText(content) {
@@ -1314,7 +1591,7 @@ function isMergeableDelta(message) {
 }
 function messageIndexKey(message) {
     if (isMergeableDelta(message)) {
-        const itemId = normalizedString(message.itemId);
+        const itemId = normalizedString(messageValue(message, "itemId"));
         return itemId == null ? undefined : `${message.type}:${itemId}`;
     }
     return normalizedString(message.messageId);
@@ -1327,30 +1604,30 @@ function mergeDeltaMessage(existing, incoming) {
         const data = new Uint8Array(existing.data.length + incoming.data.length);
         data.set(existing.data, 0);
         data.set(incoming.data, existing.data.length);
-        return new agent_messages_js_1.AgentAudioGenerationDelta({ ...existing.toJson(), data });
+        return agent_messages_js_1.AgentAudioGenerationDelta.fromJson({ ...existing.toJson(), data });
     }
     if (existing.type === agent_messages_js_1.agentAudioTranscriptionDeltaType && existing instanceof agent_messages_js_1.AgentAudioTranscriptionDelta && incoming instanceof agent_messages_js_1.AgentAudioTranscriptionDelta) {
-        return new agent_messages_js_1.AgentAudioTranscriptionDelta({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
+        return agent_messages_js_1.AgentAudioTranscriptionDelta.fromJson({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
     }
     if (existing.type === agent_messages_js_1.agentFileContentDeltaType && incoming instanceof agent_messages_js_1.AgentFileContentDelta) {
         return incoming;
     }
     if (existing.type === agent_messages_js_1.agentReasoningContentDeltaType && existing instanceof agent_messages_js_1.AgentReasoningContentDelta && incoming instanceof agent_messages_js_1.AgentReasoningContentDelta) {
-        return new agent_messages_js_1.AgentReasoningContentDelta({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
+        return agent_messages_js_1.AgentReasoningContentDelta.fromJson({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
     }
     if (existing.type === agent_messages_js_1.agentTextContentDeltaType && existing instanceof agent_messages_js_1.AgentTextContentDelta && incoming instanceof agent_messages_js_1.AgentTextContentDelta) {
-        return new agent_messages_js_1.AgentTextContentDelta({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
+        return agent_messages_js_1.AgentTextContentDelta.fromJson({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
     }
     if (existing.type === agent_messages_js_1.agentToolCallArgumentsDeltaType && existing instanceof agent_messages_js_1.AgentToolCallArgumentsDelta && incoming instanceof agent_messages_js_1.AgentToolCallArgumentsDelta) {
-        return new agent_messages_js_1.AgentToolCallArgumentsDelta({ ...existing.toJson(), delta: `${existing.delta}${incoming.delta}` });
+        return agent_messages_js_1.AgentToolCallArgumentsDelta.fromJson({ ...existing.toJson(), delta: `${existing.delta}${incoming.delta}` });
     }
     if (existing.type === agent_messages_js_1.agentToolCallLogDeltaType && existing instanceof agent_messages_js_1.AgentToolCallLogDelta && incoming instanceof agent_messages_js_1.AgentToolCallLogDelta) {
-        return new agent_messages_js_1.AgentToolCallLogDelta({ ...existing.toJson(), lines: [...existing.lines, ...incoming.lines] });
+        return agent_messages_js_1.AgentToolCallLogDelta.fromJson({ ...existing.toJson(), lines: [...existing.lines, ...incoming.lines] });
     }
     return undefined;
 }
 function normalizedString(value) {
-    const normalized = value?.trim();
+    const normalized = typeof value === "string" ? value.trim() : undefined;
     return normalized == null || normalized === "" ? undefined : normalized;
 }
 function dateOrNull(value) {