@microsoft/m365agentsplayground-cli 0.2.25-alpha.20260507-efe1416.0

package/build/testClient.d.ts

@@ -0,0 +1,146 @@
+import { EventEmitter } from "events";
+import { Message } from "server";
+import { BotResponse, TestClientConfig } from "./types";
+/**
+ * Test client for sending messages to a bot and receiving responses.
+ * Designed for testing multi-turn conversations.
+ *
+ * @example
+ * ```typescript
+ * const client = new TestClient({
+ *   botEndpoint: 'http://localhost:3978/api/messages',
+ * });
+ *
+ * await client.start();
+ *
+ * // Multi-turn conversation
+ * const [r1] = await client.sendMessage('Hello');
+ * expect(r1.text).to.include('Hi');
+ *
+ * const [r2] = await client.sendMessage('Book a flight');
+ * expect(r2.text).to.include('Where');
+ *
+ * await client.stop();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With WebSocket events
+ * const client = new TestClient({
+ *   botEndpoint: 'http://localhost:3978/api/messages',
+ * });
+ *
+ * client.on('message:created', (event) => {
+ *   console.log('New message:', event.message.text);
+ * });
+ *
+ * client.on('typing', (event) => {
+ *   console.log('Bot is typing...');
+ * });
+ *
+ * await client.start();
+ * await client.sendMessage('Hello');
+ * await client.stop();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With Log WebSocket events
+ * const client = new TestClient({
+ *   botEndpoint: 'http://localhost:3978/api/messages',
+ * });
+ *
+ * client.on('log:append', (event) => {
+ *   console.log('Log entry:', event.logItem);
+ * });
+ *
+ * await client.start();
+ * await client.sendMessage('Hello');
+ * await client.stop();
+ * ```
+ */
+export declare class TestClient extends EventEmitter {
+    /** The placeholder text teams-ai sends as the first streaming activity */
+    static readonly STREAMING_PLACEHOLDER = "Loading stream results...";
+    private serverManager;
+    private responseCapture;
+    private wsClient;
+    private logWsClient;
+    private config;
+    private conversationId;
+    private userId;
+    private started;
+    constructor(config: TestClientConfig);
+    /**
+     * Start the test client and server
+     */
+    start(): Promise<void>;
+    /**
+     * Stop the test client and server
+     */
+    stop(): Promise<void>;
+    /**
+     * Send a message to the bot and wait for response(s)
+     *
+     * @param text The message text to send
+     * @returns Array of bot responses
+     */
+    sendMessage(text: string): Promise<BotResponse[]>;
+    /**
+     * Wait for streaming to complete.
+     *
+     * Primary: resolves immediately when `streamType:"final"` WS event arrives.
+     * Fallback: resolves after `quietPeriodMs` of no new updateActivity events,
+     *   for bots that don't send streamType (e.g. non-teams-ai streaming bots).
+     * Hard cap: always resolves after `maxWaitMs`.
+     */
+    private waitForStreamFinal;
+    /**
+     * Start a new conversation (resets conversation state)
+     */
+    newConversation(): void;
+    /**
+     * Get all messages in the current conversation
+     */
+    getMessages(): Message[];
+    /**
+     * Get the last bot message in the current conversation
+     */
+    getLastBotMessage(): Message | undefined;
+    /**
+     * Get the current conversation ID
+     */
+    getConversationId(): string;
+    /**
+     * Get the port the test server is running on
+     */
+    getPort(): number;
+    /**
+     * Simulate clicking an Adaptive Card button (Action.Execute).
+     *
+     * @param messageId  The message ID of the card message (from BotResponse.messageId)
+     * @param verb       The Action.Execute verb defined on the button
+     * @param data       Optional extra data to merge with the button's own data
+     * @returns          The invoke response body from the bot
+     */
+    clickCardButton(messageId: string, verb: string, data?: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Simulate submitting an Adaptive Card form (Action.Submit / legacy bots).
+     *
+     * @param messageId  The message ID of the card message
+     * @param data       The form data to submit
+     */
+    submitCardForm(messageId: string, data: Record<string, unknown>): Promise<unknown>;
+    /**
+     * Create a unique conversation for this client based on chatType config.
+     * - personal: creates a new personal chat with a unique userId
+     * - group: creates a new group chat
+     * - channel: uses the team's general channel
+     */
+    private registerUniqueConversation;
+    /**
+     * Convert a Message to a BotResponse
+     */
+    private toBotResponse;
+}
+//# sourceMappingURL=testClient.d.ts.map

package/build/testClient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testClient.d.ts","sourceRoot":"","sources":["../src/testClient.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAW,OAAO,EAAE,MAAM,QAAQ,CAAC;AAG1C,OAAO,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyDG;AACH,qBAAa,UAAW,SAAQ,YAAY;IAC1C,0EAA0E;IAC1E,MAAM,CAAC,QAAQ,CAAC,qBAAqB,+BAA+B;IAEpE,OAAO,CAAC,aAAa,CAAgB;IACrC,OAAO,CAAC,eAAe,CAAkB;IACzC,OAAO,CAAC,QAAQ,CAAgC;IAChD,OAAO,CAAC,WAAW,CAAmC;IACtD,OAAO,CAAC,MAAM,CAAmB;IACjC,OAAO,CAAC,cAAc,CAAM;IAC5B,OAAO,CAAC,MAAM,CAAM;IACpB,OAAO,CAAC,OAAO,CAAS;gBAEZ,MAAM,EAAE,gBAAgB;IAUpC;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAyD5B;;OAEG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAqB3B;;;;;OAKG;IACG,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;IA2GvD;;;;;;;OAOG;YACW,kBAAkB;IAoChC;;OAEG;IACH,eAAe,IAAI,IAAI;IAYvB;;OAEG;IACH,WAAW,IAAI,OAAO,EAAE;IASxB;;OAEG;IACH,iBAAiB,IAAI,OAAO,GAAG,SAAS;IAMxC;;OAEG;IACH,iBAAiB,IAAI,MAAM;IAI3B;;OAEG;IACH,OAAO,IAAI,MAAM;IAIjB;;;;;;;OAOG;IACG,eAAe,CACnB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,EACZ,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACjC,OAAO,CAAC,OAAO,CAAC;IAkCnB;;;;;OAKG;IACG,cAAc,CAClB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC5B,OAAO,CAAC,OAAO,CAAC;IA4BnB;;;;;OAKG;IACH,OAAO,CAAC,0BAA0B;IAiClC;;OAEG;IACH,OAAO,CAAC,aAAa;CAStB"}

package/build/testClient.js

@@ -0,0 +1,434 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestClient = void 0;
+const events_1 = require("events");
+const schema_1 = require("schema");
+const server_1 = require("server");
+const serverManager_1 = require("./serverManager");
+const websocketClient_1 = require("./websocketClient");
+/**
+ * Test client for sending messages to a bot and receiving responses.
+ * Designed for testing multi-turn conversations.
+ *
+ * @example
+ * ```typescript
+ * const client = new TestClient({
+ *   botEndpoint: 'http://localhost:3978/api/messages',
+ * });
+ *
+ * await client.start();
+ *
+ * // Multi-turn conversation
+ * const [r1] = await client.sendMessage('Hello');
+ * expect(r1.text).to.include('Hi');
+ *
+ * const [r2] = await client.sendMessage('Book a flight');
+ * expect(r2.text).to.include('Where');
+ *
+ * await client.stop();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With WebSocket events
+ * const client = new TestClient({
+ *   botEndpoint: 'http://localhost:3978/api/messages',
+ * });
+ *
+ * client.on('message:created', (event) => {
+ *   console.log('New message:', event.message.text);
+ * });
+ *
+ * client.on('typing', (event) => {
+ *   console.log('Bot is typing...');
+ * });
+ *
+ * await client.start();
+ * await client.sendMessage('Hello');
+ * await client.stop();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // With Log WebSocket events
+ * const client = new TestClient({
+ *   botEndpoint: 'http://localhost:3978/api/messages',
+ * });
+ *
+ * client.on('log:append', (event) => {
+ *   console.log('Log entry:', event.logItem);
+ * });
+ *
+ * await client.start();
+ * await client.sendMessage('Hello');
+ * await client.stop();
+ * ```
+ */
+class TestClient extends events_1.EventEmitter {
+    /** The placeholder text teams-ai sends as the first streaming activity */
+    static STREAMING_PLACEHOLDER = "Loading stream results...";
+    serverManager;
+    responseCapture;
+    wsClient = null;
+    logWsClient = null;
+    config;
+    conversationId = "";
+    userId = "";
+    started = false;
+    constructor(config) {
+        super();
+        this.config = {
+            timeout: 5000,
+            ...config,
+        };
+        this.serverManager = new serverManager_1.ServerManager();
+        this.responseCapture = serverManager_1.ServerManager.getResponseCapture();
+    }
+    /**
+     * Start the test client and server
+     */
+    async start() {
+        if (this.started) {
+            throw new Error("TestClient is already started");
+        }
+        await this.serverManager.start(this.config);
+        // Create a unique conversation for this client
+        this.registerUniqueConversation();
+        // Connect to WebSocket for real-time events
+        this.wsClient = new websocketClient_1.WebSocketClient({
+            port: this.serverManager.port,
+            onMessage: (action) => {
+                switch (action.action) {
+                    case schema_1.ActionType.CreateMessage:
+                        this.emit("message:created", action);
+                        break;
+                    case schema_1.ActionType.UpdateMessage:
+                        this.emit("message:updated", action);
+                        break;
+                    case schema_1.ActionType.Typing:
+                        this.emit("typing", action);
+                        break;
+                }
+            },
+            onError: (err) => {
+                this.emit("websocket:error", err);
+            },
+            onClose: () => {
+                this.emit("websocket:close");
+            },
+        });
+        await this.wsClient.connect();
+        // Connect to Log WebSocket for log events
+        this.logWsClient = new websocketClient_1.LogWebSocketClient({
+            port: this.serverManager.port,
+            onLogMessage: (action) => {
+                if (action.logAction === schema_1.LogActionType.AppendLog) {
+                    this.emit("log:append", action);
+                }
+            },
+            onError: (err) => {
+                this.emit("log:websocket:error", err);
+            },
+            onClose: () => {
+                this.emit("log:websocket:close");
+            },
+        });
+        await this.logWsClient.connect();
+        this.started = true;
+    }
+    /**
+     * Stop the test client and server
+     */
+    async stop() {
+        if (!this.started) {
+            return;
+        }
+        // Close WebSocket connections
+        if (this.wsClient) {
+            this.wsClient.close();
+            this.wsClient = null;
+        }
+        if (this.logWsClient) {
+            this.logWsClient.close();
+            this.logWsClient = null;
+        }
+        this.responseCapture.clearConversation(this.conversationId);
+        await this.serverManager.stop();
+        this.started = false;
+    }
+    /**
+     * Send a message to the bot and wait for response(s)
+     *
+     * @param text The message text to send
+     * @returns Array of bot responses
+     */
+    async sendMessage(text) {
+        if (!this.started) {
+            throw new Error("TestClient is not started. Call start() first.");
+        }
+        const conversationManager = server_1.Factory.getConversationManager();
+        const messageService = server_1.Factory.getMessageService();
+        // Get the conversation
+        const conversation = conversationManager.getConversation(this.conversationId);
+        // Track message updates received via WebSocket (for streaming bots).
+        const messageUpdates = new Map(); // messageId → latest text
+        let streamFinalReceived = false; // set when streamType:"final" arrives
+        let lastUpdateTime = Date.now(); // epoch ms of last update (or conversation start)
+        const updateListener = (action) => {
+            const id = action.message?.messageId;
+            const msg = action.message;
+            if (id && msg.text !== undefined) {
+                messageUpdates.set(id, msg.text);
+                lastUpdateTime = Date.now();
+                if (msg.streamEntity?.streamType === "final") {
+                    streamFinalReceived = true;
+                }
+            }
+        };
+        this.on("message:updated", updateListener);
+        // Create the message request
+        const messagePayload = {
+            text,
+            textFormat: "plain",
+            from: { id: this.userId },
+        };
+        // Start waiting for response before sending (to avoid race conditions)
+        const responsePromise = this.responseCapture.waitForResponse(this.conversationId, conversationManager, this.config.timeout ?? 5000);
+        // Send the message
+        const { afterAll } = messageService.createMessage(conversation, messagePayload);
+        // Execute the async send
+        if (afterAll) {
+            afterAll();
+        }
+        // Wait for the first bot response (may be a streaming placeholder)
+        await responsePromise;
+        // Get the initial bot messages to check for streaming placeholder
+        const allMessages = conversationManager.listMessages(this.conversationId);
+        const lastUserIdx = allMessages.reduce((lastIdx, msg, idx) => (msg.createdBy === "client" ? idx : lastIdx), -1);
+        const initialBotMessages = allMessages
+            .slice(lastUserIdx + 1)
+            .filter((m) => m.createdBy === "bot");
+        const isStreamingPlaceholder = initialBotMessages.some((m) => m.content.text === TestClient.STREAMING_PLACEHOLDER);
+        if (isStreamingPlaceholder) {
+            // Streaming bot detected.
+            // Primary signal: wait for streamType:"final" WS event (teams-ai / teams.ts SDK).
+            // Fallback: quiet-period in case the bot doesn't send streamType at all.
+            const quietPeriodMs = this.config.streamingSettleDelayMs ?? 800;
+            const maxWaitMs = this.config.timeout ?? 30000;
+            await this.waitForStreamFinal(() => streamFinalReceived, () => lastUpdateTime, quietPeriodMs, maxWaitMs);
+        }
+        this.off("message:updated", updateListener);
+        // Re-read messages after any streaming updates have landed
+        const messages = conversationManager.listMessages(this.conversationId);
+        const lastUserMessageIndex = messages.reduce((lastIndex, msg, index) => {
+            if (msg.createdBy === "client") {
+                return index;
+            }
+            return lastIndex;
+        }, -1);
+        const recentBotMessages = messages
+            .slice(lastUserMessageIndex + 1)
+            .filter((m) => m.createdBy === "bot");
+        return recentBotMessages.map((msg) => {
+            const response = this.toBotResponse(msg);
+            // If this message was updated via streaming, use the final streamed text
+            const streamedText = messageUpdates.get(response.messageId);
+            if (streamedText !== undefined) {
+                response.text = streamedText;
+            }
+            return response;
+        });
+    }
+    /**
+     * Wait for streaming to complete.
+     *
+     * Primary: resolves immediately when `streamType:"final"` WS event arrives.
+     * Fallback: resolves after `quietPeriodMs` of no new updateActivity events,
+     *   for bots that don't send streamType (e.g. non-teams-ai streaming bots).
+     * Hard cap: always resolves after `maxWaitMs`.
+     */
+    async waitForStreamFinal(isFinalReceived, getLastUpdateTime, quietPeriodMs, maxWaitMs) {
+        return new Promise((resolve) => {
+            const deadline = Date.now() + maxWaitMs;
+            const poll = () => {
+                // Primary signal: streamType:"final" received
+                if (isFinalReceived()) {
+                    resolve();
+                    return;
+                }
+                const now = Date.now();
+                if (now >= deadline) {
+                    resolve();
+                    return;
+                }
+                const lastUpdate = getLastUpdateTime();
+                // Fallback: quiet period after last update
+                if (lastUpdate > 0 && now - lastUpdate >= quietPeriodMs) {
+                    resolve();
+                    return;
+                }
+                setTimeout(poll, 50);
+            };
+            setTimeout(poll, 50);
+        });
+    }
+    /**
+     * Start a new conversation (resets conversation state)
+     */
+    newConversation() {
+        if (!this.started) {
+            throw new Error("TestClient is not started. Call start() first.");
+        }
+        // Clear pending responses for the old conversation
+        this.responseCapture.clearConversation(this.conversationId);
+        // Create a fresh unique conversation
+        this.registerUniqueConversation();
+    }
+    /**
+     * Get all messages in the current conversation
+     */
+    getMessages() {
+        if (!this.started) {
+            throw new Error("TestClient is not started. Call start() first.");
+        }
+        const conversationManager = server_1.Factory.getConversationManager();
+        return conversationManager.listMessages(this.conversationId);
+    }
+    /**
+     * Get the last bot message in the current conversation
+     */
+    getLastBotMessage() {
+        const messages = this.getMessages();
+        const botMessages = messages.filter((m) => m.createdBy === "bot");
+        return botMessages[botMessages.length - 1];
+    }
+    /**
+     * Get the current conversation ID
+     */
+    getConversationId() {
+        return this.conversationId;
+    }
+    /**
+     * Get the port the test server is running on
+     */
+    getPort() {
+        return this.serverManager.port;
+    }
+    /**
+     * Simulate clicking an Adaptive Card button (Action.Execute).
+     *
+     * @param messageId  The message ID of the card message (from BotResponse.messageId)
+     * @param verb       The Action.Execute verb defined on the button
+     * @param data       Optional extra data to merge with the button's own data
+     * @returns          The invoke response body from the bot
+     */
+    async clickCardButton(messageId, verb, data = {}) {
+        if (!this.started) {
+            throw new Error("TestClient is not started. Call start() first.");
+        }
+        const port = this.serverManager.port;
+        const meId = server_1.Factory.getTenantManager().getMe().id;
+        const body = {
+            name: "adaptiveCard/action",
+            conversation: { id: this.conversationId },
+            from: { id: meId },
+            replyToId: messageId,
+            value: {
+                action: {
+                    type: "Action.Execute",
+                    verb,
+                    data,
+                },
+            },
+        };
+        const res = await fetch(`http://localhost:${port}/_conversation/v1/invoke`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            throw new Error(`Card action invoke failed: HTTP ${res.status}`);
+        }
+        return res.json();
+    }
+    /**
+     * Simulate submitting an Adaptive Card form (Action.Submit / legacy bots).
+     *
+     * @param messageId  The message ID of the card message
+     * @param data       The form data to submit
+     */
+    async submitCardForm(messageId, data) {
+        if (!this.started) {
+            throw new Error("TestClient is not started. Call start() first.");
+        }
+        const port = this.serverManager.port;
+        const meId = server_1.Factory.getTenantManager().getMe().id;
+        const body = {
+            name: "message/submitAction",
+            conversation: { id: this.conversationId },
+            from: { id: meId },
+            replyToId: messageId,
+            value: data,
+        };
+        const res = await fetch(`http://localhost:${port}/_conversation/v1/invoke`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        if (!res.ok) {
+            throw new Error(`Card form submit failed: HTTP ${res.status}`);
+        }
+        return res.json();
+    }
+    /**
+     * Create a unique conversation for this client based on chatType config.
+     * - personal: creates a new personal chat with a unique userId
+     * - group: creates a new group chat
+     * - channel: uses the team's general channel
+     */
+    registerUniqueConversation() {
+        const chatType = this.config.chatType ?? "personal";
+        const chatManager = server_1.Factory.getChatManager();
+        const conversationManager = server_1.Factory.getConversationManager();
+        if (chatType === "group") {
+            const chat = chatManager.createGroupChat(`test-group-${Date.now()}`);
+            const conversation = conversationManager.createConversation(chat);
+            this.conversationId = conversation.id;
+            this.userId = server_1.Factory.getTenantManager().getMe().id;
+        }
+        else if (chatType === "channel") {
+            const teamManager = server_1.Factory.getTeamManager();
+            const channel = teamManager.getGeneralChannel();
+            const conversation = conversationManager.createConversation(channel);
+            this.conversationId = conversation.id;
+            this.userId = server_1.Factory.getTenantManager().getMe().id;
+        }
+        else {
+            this.userId = `test-user-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+            const chat = chatManager.createPersonalChat(this.userId, "Test Chat");
+            const conversation = conversationManager.createConversation(chat);
+            this.conversationId = conversation.id;
+            // Replace the fake userId in the chat's user set with the real "me" user so that:
+            //   1. isOtherUserChat() returns false → WebSocket events are broadcast to this client
+            //   2. getChatUsers() doesn't throw when looking up the fake userId in the tenant
+            // Using 'as any' is intentional — ChatManager has no public addUserToChat API and
+            // this is simulator-only setup code, not production logic.
+            const meId = server_1.Factory.getTenantManager().getMe().id;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            chatManager._chatUsers.set(chat.id, new Set([meId]));
+        }
+    }
+    /**
+     * Convert a Message to a BotResponse
+     */
+    toBotResponse(message) {
+        return {
+            messageId: message.content.id,
+            text: message.content.text,
+            attachments: message.content.attachments,
+            timestamp: message.content.timestamp.getTime(),
+            raw: message,
+        };
+    }
+}
+exports.TestClient = TestClient;