@meshagent/meshagent-agents 0.47.1 → 0.48.0

package/dist/esm/chat-client.js

@@ -1,16 +1,34 @@
 import { Completer, } from "@meshagent/meshagent";
+import { decode, encode } from "@msgpack/msgpack";
+import WebSocket from "isomorphic-ws";
 import { v4 as uuidv4 } from "uuid";
-import { AgentMessage as AgentMessageFactory, AgentAudioGenerationDelta, AgentAudioTranscriptionDelta, AgentRealtimeAudioChunk, AgentRealtimeAudioCommit, AgentFileContentDelta, AgentModelChanged, AgentReasoningContentDelta, AgentTextContentDelta, AgentThreadStatus, AgentToolCallArgumentsDelta, AgentToolCallLogDelta, ChangeModel, CloseThread, DeleteThread, ModelsResponse, ModelsRequest, OpenThread, RenameThread, StartThread, AgentConnectionStatus, TurnInterrupt, TurnStart, TurnSteer, AgentClientToolCallRequested, AgentClientToolCallResponse, agentInputContent, agentAudioGenerationDeltaType, agentAudioTranscriptionDeltaType, agentFileContentDeltaType, agentImageGenerationCompletedType, agentImageGenerationPartialType, agentModelChangedType, agentModelsResponseType, agentReasoningContentDeltaType, agentRoomMessageType, agentTextContentDeltaType, agentThreadClearedType, agentThreadCreatedType, agentThreadDeletedType, agentThreadLoadedType, agentThreadListedType, agentThreadCloseType, agentThreadOpenType, agentThreadUnwatchType, agentThreadUpdatedType, agentThreadWatchType, agentConnectionStatusType, agentThreadStatusType, agentThreadStartType, agentThreadStartRejectedType, agentThreadStartedType, agentToolCallArgumentsDeltaType, agentToolCallLogDeltaType, agentToolCallEndedType, agentToolCallInProgressType, agentToolCallPendingType, agentToolCallStartedType, agentSecretRequestedType, agentTurnEndedType, agentTurnInterruptAcceptedType, agentTurnInterruptedType, agentTurnStartAcceptedType, agentTurnStartRejectedType, agentTurnStartType, agentTurnStartedType, agentTurnSteerAcceptedType, agentTurnSteerRejectedType, agentTurnSteerType, agentTurnSteeredType, agentUsageUpdatedType, } from "./agent-messages.js";
+import { AgentMessage as AgentMessageFactory, AgentThreadMessage, AgentAudioFormat, AgentAudioGenerationDelta, AgentAudioTranscriptionDelta, AgentRealtimeAudioChunk, AgentRealtimeAudioCommit, AgentFileContentDelta, AgentImageGenerationCompleted, AgentImageGenerationPartial, AgentReasoningContentDelta, AgentTextContentDelta, AgentToolCallArgumentsDelta, AgentToolCallLogDelta, ChangeModel, CloseThread, DeleteThread, InjectMessages, ModelsRequest, OpenThread, RenameThread, StartThread, ThreadCreated, ThreadStarted, AgentConnectionStatus, TurnEnded, TurnInterrupt, TurnStart, TurnStartAccepted, TurnSteer, UnwatchThreads, WatchThreads, AgentClientToolCallRequested, AgentClientToolCallResponse, agentInputContent, agentAudioGenerationDeltaType, agentAudioTranscriptionDeltaType, agentFileContentDeltaType, agentReasoningContentDeltaType, agentRoomMessageType, agentTextContentDeltaType, agentThreadClearedType, agentThreadCreatedType, agentThreadDeletedType, agentThreadLoadedType, agentThreadListedType, agentThreadUpdatedType, agentConnectionStatusType, agentThreadStartType, agentThreadStartRejectedType, agentThreadStartedType, agentToolCallArgumentsDeltaType, agentToolCallLogDeltaType, agentTurnEndedType, agentTurnStartAcceptedType, agentTurnStartRejectedType, agentTurnStartType, agentTurnStartedType, agentTurnSteerAcceptedType, agentTurnSteerRejectedType, agentTurnSteerType, agentTurnSteeredType, } from "./agent-messages.js";
 import { ChangeEmitter } from "./change-emitter.js";
 export 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();
+        }
+    }
 }
 function agentRoomMessageFromEvent(event) {
     const candidate = event.message;
@@ -92,6 +110,12 @@ export class ChatThreadStartResult {
         this.realtimeConnection = realtimeConnection;
     }
 }
+export class PendingThreadStartCandidate {
+    constructor({ messageId, senderName }) {
+        this.messageId = messageId;
+        this.senderName = senderName;
+    }
+}
 class EventQueue {
     constructor() {
         this.subscribers = new Set();
@@ -144,12 +168,15 @@ class EventQueue {
     }
 }
 export class BaseChatClient extends 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;
@@ -171,14 +198,41 @@ export class BaseChatClient extends 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");
@@ -190,11 +244,8 @@ export class BaseChatClient extends 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;
@@ -204,7 +255,7 @@ export class BaseChatClient extends 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() === "" ? uuidv4() : messageId.trim();
         const resolvedSenderName = this.cleanParticipantName(senderName) ?? this.localParticipantName();
         const payload = new StartThread({
@@ -219,10 +270,9 @@ export class BaseChatClient extends ChangeEmitter {
             realtimeProtocol: nonEmptyTrimmed(realtimeProtocol),
             senderName: resolvedSenderName,
             clientToolkits: clientToolkits != null && clientToolkits.length > 0 ? clientToolkits : undefined,
-            toolChoice: toolChoice?.toJson(),
         });
         const completer = new Completer();
-        this.pendingStartRequests.set(resolvedMessageId, completer);
+        this.pendingStartRequests.set(resolvedMessageId, { request: payload, completer });
         try {
             await this.sendAgentMessage(payload);
             const response = await completer.fut;
@@ -232,18 +282,18 @@ export class BaseChatClient extends 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 === agentThreadStartedType && response.realtimeConnection != null
+                realtimeConnection: response instanceof ThreadStarted && response.realtimeConnection != null
                     ? response.realtimeConnection.toJson()
                     : undefined,
             });
@@ -267,6 +317,7 @@ export class BaseChatClient extends ChangeEmitter {
             mcp: payload.mcp,
             clientToolkits: payload.clientToolkits,
             toolkits: payload.toolkits,
+            toolChoice: payload.toolChoice,
         });
     }
     drainPendingSessionEvents(threadPath, session) {
@@ -280,9 +331,13 @@ export class BaseChatClient extends ChangeEmitter {
         }
     }
     handleAgentMessage(message, { createdAt, attachment } = {}) {
-        if (message instanceof AgentClientToolCallRequested &&
-            !this.isClientToolCallForLocalParticipant(message)) {
-            return;
+        if (message instanceof AgentClientToolCallRequested) {
+            const targetParticipantId = message.targetParticipantId?.trim();
+            if (targetParticipantId != null &&
+                targetParticipantId !== "" &&
+                targetParticipantId !== this.localParticipantId()) {
+                return;
+            }
         }
         if (message.type === agentConnectionStatusType) {
             this._connectionStatus = message;
@@ -293,10 +348,13 @@ export class BaseChatClient extends 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 ThreadCreated) {
+            this.acknowledgePendingStartFromThreadCreated(message);
+        }
         const threadPath = "threadId" in message ? String(message.threadId).trim() : "";
         if (threadPath === "") {
             this.notifyListeners();
@@ -314,6 +372,40 @@ export class BaseChatClient extends 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 ThreadStarted({
+            sourceMessageId: matchedMessageId,
+            threadId: threadPath,
+        }));
+    }
     emitConnectionStatus({ status, message, reason, retryDelay, }) {
         const event = new AgentConnectionStatus({
             status,
@@ -367,9 +459,17 @@ export class ThreadListSubscribe {
         await this.stream.close();
     }
 }
+function participantWaitAbortedError(reason) {
+    if (reason instanceof Error) {
+        return reason;
+    }
+    const error = new Error("Agent participant wait was cancelled.");
+    error.name = "AbortError";
+    return error;
+}
 export 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;
@@ -466,7 +566,7 @@ export 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();
     }
@@ -517,7 +617,13 @@ export 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;
@@ -525,12 +631,34 @@ export class BaseMessagingChatClient extends BaseChatClient {
         const key = waitKey == null || waitKey.trim() === "" ? uuidv4() : waitKey.trim();
         const completer = new 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 } = {}) {
@@ -584,6 +712,254 @@ export class BaseMessagingChatClient extends BaseChatClient {
         }
     }
 }
+export 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 = decode(bytes);
+                if (!isJsonMap(decoded)) {
+                    throw new Error("chat websocket received a non-object message");
+                }
+                const message = AgentMessageFactory.fromJson(decoded);
+                if (message instanceof 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 === WebSocket.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 WebSocket(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 !== WebSocket.OPEN) {
+            throw new Error(this.closedMessage());
+        }
+        webSocket.send(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";
+    }
+}
 export class MessagingChatClient extends BaseMessagingChatClient {
     constructor() {
         super(...arguments);
@@ -647,7 +1023,7 @@ export class MessagingChatClient extends BaseMessagingChatClient {
             await super.sendAgentMessage(message, { attachment });
             return;
         }
-        if (message.type === agentThreadOpenType) {
+        if (message instanceof OpenThread) {
             const previous = this.threadSubscriptions.get(message.threadId);
             if (previous != null) {
                 await previous.close();
@@ -663,7 +1039,7 @@ export class MessagingChatClient extends BaseMessagingChatClient {
             this.trackStream(subscription);
             return;
         }
-        if (message.type === agentThreadCloseType) {
+        if (message instanceof CloseThread) {
             const subscription = this.threadSubscriptions.get(message.threadId);
             if (subscription != null) {
                 this.threadSubscriptions.delete(message.threadId);
@@ -671,7 +1047,7 @@ export class MessagingChatClient extends BaseMessagingChatClient {
                 return;
             }
         }
-        if (message.type === agentThreadWatchType) {
+        if (message instanceof WatchThreads) {
             await this.threadListSubscription?.close();
             const stream = await this.room.messaging.stream({
                 to: participant,
@@ -684,7 +1060,7 @@ export class MessagingChatClient extends BaseMessagingChatClient {
             this.trackStream(subscription);
             return;
         }
-        if (message.type === agentThreadUnwatchType && this.threadListSubscription != null) {
+        if (message instanceof UnwatchThreads && this.threadListSubscription != null) {
             const subscription = this.threadListSubscription;
             this.threadListSubscription = undefined;
             await subscription.close();
@@ -722,6 +1098,9 @@ export class ChatThreadSession extends ChangeEmitter {
         this.client = client;
         this.threadPath = threadPath;
     }
+    static create({ client, threadPath }) {
+        return new ChatThreadSession({ client, threadPath });
+    }
     get messages() {
         return [...this._messages];
     }
@@ -740,18 +1119,6 @@ export class ChatThreadSession extends 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) {
@@ -766,7 +1133,6 @@ export class ChatThreadSession extends ChangeEmitter {
                 }
                 catch (error) {
                     this.setLoadState(this.failedLoadState(error));
-                    throw error;
                 }
             }
             return;
@@ -785,7 +1151,6 @@ export class ChatThreadSession extends ChangeEmitter {
         }
         catch (error) {
             this.setLoadState(this.failedLoadState(error));
-            throw error;
         }
     }
     resetReplayState() {
@@ -832,16 +1197,20 @@ export class ChatThreadSession extends 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 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() === "" ? uuidv4() : 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 TurnSteer({
                 threadId: this.threadPath,
@@ -855,13 +1224,12 @@ export class ChatThreadSession extends ChangeEmitter {
                 messageId: resolvedMessageId,
                 senderName: nonEmptyTrimmed(senderName),
                 content: 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);
@@ -880,10 +1248,10 @@ export class ChatThreadSession extends ChangeEmitter {
         await this.client.sendAgentMessage(new AgentRealtimeAudioChunk({
             threadId: this.threadPath,
             messageId: uuidv4(),
-            format,
+            format: new AgentAudioFormat(format),
         }), { attachment: chunk });
     }
-    async commitRealtimeAudio({ turnId, provider, model, voice, outputModalities, }) {
+    async commitRealtimeAudio({ turnId, backend, provider, model, voice, outputModalities, }) {
         const messageId = uuidv4();
         await this.client.sendAgentMessage(new AgentRealtimeAudioCommit({
             threadId: this.threadPath,
@@ -894,6 +1262,7 @@ export class ChatThreadSession extends ChangeEmitter {
             threadId: this.threadPath,
             messageId: uuidv4(),
             turnId,
+            backend: nonEmptyTrimmed(backend),
             provider: nonEmptyTrimmed(provider),
             model: nonEmptyTrimmed(model),
             voice: nonEmptyTrimmed(voice),
@@ -922,56 +1291,9 @@ export class ChatThreadSession extends 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 === agentTurnStartAcceptedType || message.type === agentTurnStartedType) {
-            const turnId = normalizedString(threadMessageValue(message, "turnId"));
-            if (turnId != null) {
-                this.activeTurnIdValue = turnId;
-            }
-            if (message.type === agentTurnStartedType) {
-                const statusTurnId = normalizedString(this.threadStatusValue?.turnId);
-                if (statusTurnId == null || statusTurnId === turnId) {
-                    this.threadStatusValue = undefined;
-                }
-            }
-            return;
-        }
-        if (message.type === agentThreadStatusType && message instanceof 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 === agentModelChangedType && message instanceof AgentModelChanged) {
-            this.currentModelValue = message;
-            return;
-        }
-        if (message.type === agentModelsResponseType && message instanceof ModelsResponse) {
-            this.modelsResponseValue = message;
-            this.applyActiveModel(message);
-            return;
-        }
-        if (message.type === agentThreadLoadedType) {
+        else if (message.type === agentThreadLoadedType) {
             this.setLoadState(new ChatThreadSessionLoadState({
                 phase: ChatThreadSessionLoadPhase.Loaded,
                 startedAt: this.loadStateValue.startedAt,
@@ -1049,45 +1371,21 @@ export class ChatThreadSession extends ChangeEmitter {
     }
     appendRenderableMessage(event) {
         const message = event.message;
-        if (message.type === agentTurnEndedType) {
-            if (message.error != null) {
-                this.appendMessage(event);
-            }
-            return;
-        }
-        if (message.type === 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 === agentToolCallPendingType || message.type === agentToolCallInProgressType || message.type === agentToolCallStartedType) {
-            const itemId = normalizedString(message.itemId);
-            if (itemId != null) {
-                this.upsertItemMessage(`tool_call:${itemId}`, event);
-            }
-            return;
-        }
-        if (message.type === agentSecretRequestedType) {
+        if (message instanceof TurnEnded) {
             this.appendMessage(event);
             return;
         }
-        if (message.type === agentModelChangedType) {
-            this.appendMessage(event);
-            return;
-        }
-        if (message.type === agentThreadStartType || message.type === agentTurnStartType || message.type === agentTurnSteerType) {
-            if (agentInputText(message.content).trim() !== "") {
+        if (message instanceof StartThread || message instanceof TurnStart || message instanceof 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 === agentTurnStartAcceptedType || message.type === agentTurnSteerAcceptedType) {
-            const sourceMessageId = normalizedString(sourceMessageIdFor(message));
+        if (message instanceof TurnStartAccepted) {
+            const sourceMessageId = normalizedString(message.sourceMessageId);
             if (sourceMessageId != null && this.localAgentMessageIds.has(sourceMessageId)) {
                 this.pendingLocalInputMessageIds.delete(sourceMessageId);
                 return;
@@ -1095,36 +1393,21 @@ export class ChatThreadSession extends ChangeEmitter {
             if (agentInputText(message.content).trim() !== "") {
                 this.appendMessage(event, { beforePendingLocalInputs: true });
             }
-            else {
-                this.appendMessage(event);
-            }
-            return;
-        }
-        if (message.type === agentTurnStartedType ||
-            message.type === agentTurnSteeredType ||
-            message.type === agentTurnStartRejectedType ||
-            message.type === agentTurnSteerRejectedType ||
-            message.type === agentTurnInterruptAcceptedType ||
-            message.type === agentTurnInterruptedType) {
-            this.appendMessage(event);
             return;
         }
         if (isMergeableDelta(message)) {
             this.appendOrMergeDelta(event);
             return;
         }
-        if (message.type === agentImageGenerationPartialType || message.type === agentImageGenerationCompletedType) {
-            const itemId = normalizedString(message.itemId);
-            if (itemId != null) {
-                this.upsertItemMessage(`image_generation:${itemId}`, event);
-            }
+        if (message instanceof AgentImageGenerationPartial || message instanceof AgentImageGenerationCompleted) {
+            this.appendMessage(event);
             return;
         }
-        if (message.type === agentUsageUpdatedType) {
+        if (message instanceof AgentClientToolCallRequested) {
             this.appendMessage(event);
             return;
         }
-        if (message instanceof AgentClientToolCallRequested) {
+        if (message instanceof AgentConnectionStatus || message instanceof AgentThreadMessage) {
             this.appendMessage(event);
         }
     }
@@ -1144,15 +1427,6 @@ export class ChatThreadSession extends 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);
@@ -1162,7 +1436,7 @@ export class ChatThreadSession extends ChangeEmitter {
             }
             this.mergedDeltaMessageIds.add(normalizedMessageId);
         }
-        const itemId = normalizedString(message.itemId);
+        const itemId = normalizedString(messageValue(message, "itemId"));
         if (itemId == null) {
             return;
         }
@@ -1176,7 +1450,7 @@ export class ChatThreadSession extends 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) {
@@ -1187,29 +1461,6 @@ export class ChatThreadSession extends ChangeEmitter {
             }
         }
     }
-    applyActiveModel(response) {
-        for (const provider of response.providers) {
-            for (const model of provider.models) {
-                if (!model.active) {
-                    continue;
-                }
-                this.currentModelValue = new 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({
@@ -1268,12 +1519,33 @@ export class ChatThreadSession extends ChangeEmitter {
         }));
     }
 }
+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) {
@@ -1301,7 +1573,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);
@@ -1314,30 +1586,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 AgentAudioGenerationDelta({ ...existing.toJson(), data });
+        return AgentAudioGenerationDelta.fromJson({ ...existing.toJson(), data });
     }
     if (existing.type === agentAudioTranscriptionDeltaType && existing instanceof AgentAudioTranscriptionDelta && incoming instanceof AgentAudioTranscriptionDelta) {
-        return new AgentAudioTranscriptionDelta({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
+        return AgentAudioTranscriptionDelta.fromJson({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
     }
     if (existing.type === agentFileContentDeltaType && incoming instanceof AgentFileContentDelta) {
         return incoming;
     }
     if (existing.type === agentReasoningContentDeltaType && existing instanceof AgentReasoningContentDelta && incoming instanceof AgentReasoningContentDelta) {
-        return new AgentReasoningContentDelta({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
+        return AgentReasoningContentDelta.fromJson({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
     }
     if (existing.type === agentTextContentDeltaType && existing instanceof AgentTextContentDelta && incoming instanceof AgentTextContentDelta) {
-        return new AgentTextContentDelta({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
+        return AgentTextContentDelta.fromJson({ ...existing.toJson(), text: `${existing.text}${incoming.text}` });
     }
     if (existing.type === agentToolCallArgumentsDeltaType && existing instanceof AgentToolCallArgumentsDelta && incoming instanceof AgentToolCallArgumentsDelta) {
-        return new AgentToolCallArgumentsDelta({ ...existing.toJson(), delta: `${existing.delta}${incoming.delta}` });
+        return AgentToolCallArgumentsDelta.fromJson({ ...existing.toJson(), delta: `${existing.delta}${incoming.delta}` });
     }
     if (existing.type === agentToolCallLogDeltaType && existing instanceof AgentToolCallLogDelta && incoming instanceof AgentToolCallLogDelta) {
-        return new AgentToolCallLogDelta({ ...existing.toJson(), lines: [...existing.lines, ...incoming.lines] });
+        return 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) {