@microsoft/m365agentsplayground-cli 0.2.26 → 0.2.27

package/src/testClient.ts

@@ -1,512 +0,0 @@
-import { EventEmitter } from "events";
-import { ActionType, ICreateMessageRequest, LogActionType, IUpdateMessageAction } from "schema";
-import { Factory, Message } from "server";
-import { ResponseCapture } from "./responseCapture";
-import { ServerManager } from "./serverManager";
-import { BotResponse, TestClientConfig } from "./types";
-import { LogWebSocketClient, WebSocketClient } from "./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();
- * ```
- */
-export class TestClient extends EventEmitter {
-  /** The placeholder text teams-ai sends as the first streaming activity */
-  static readonly STREAMING_PLACEHOLDER = "Loading stream results...";
-
-  private serverManager: ServerManager;
-  private responseCapture: ResponseCapture;
-  private wsClient: WebSocketClient | null = null;
-  private logWsClient: LogWebSocketClient | null = null;
-  private config: TestClientConfig;
-  private conversationId = "";
-  private userId = "";
-  private started = false;
-
-  constructor(config: TestClientConfig) {
-    super();
-    this.config = {
-      timeout: 5000,
-      ...config,
-    };
-    this.serverManager = new ServerManager();
-    this.responseCapture = ServerManager.getResponseCapture();
-  }
-
-  /**
-   * Start the test client and server
-   */
-  async start(): Promise<void> {
-    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({
-      port: this.serverManager.port,
-      onMessage: (action) => {
-        switch (action.action) {
-          case ActionType.CreateMessage:
-            this.emit("message:created", action);
-            break;
-          case ActionType.UpdateMessage:
-            this.emit("message:updated", action);
-            break;
-          case 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 LogWebSocketClient({
-      port: this.serverManager.port,
-      onLogMessage: (action) => {
-        if (action.logAction === 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(): Promise<void> {
-    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: string): Promise<BotResponse[]> {
-    if (!this.started) {
-      throw new Error("TestClient is not started. Call start() first.");
-    }
-
-    const conversationManager = Factory.getConversationManager();
-    const messageService = Factory.getMessageService();
-
-    // Get the conversation
-    const conversation = conversationManager.getConversation(this.conversationId);
-
-    // Track message updates received via WebSocket (for streaming bots).
-    const messageUpdates = new Map<string, string>(); // 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: IUpdateMessageAction) => {
-      const id = action.message?.messageId;
-      const msg = action.message as { text?: string; streamEntity?: { streamType?: string } };
-      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: ICreateMessageRequest = {
-      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`.
-   */
-  private async waitForStreamFinal(
-    isFinalReceived: () => boolean,
-    getLastUpdateTime: () => number,
-    quietPeriodMs: number,
-    maxWaitMs: number
-  ): Promise<void> {
-    return new Promise<void>((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(): void {
-    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(): Message[] {
-    if (!this.started) {
-      throw new Error("TestClient is not started. Call start() first.");
-    }
-
-    const conversationManager = Factory.getConversationManager();
-    return conversationManager.listMessages(this.conversationId);
-  }
-
-  /**
-   * Get the last bot message in the current conversation
-   */
-  getLastBotMessage(): Message | undefined {
-    const messages = this.getMessages();
-    const botMessages = messages.filter((m) => m.createdBy === "bot");
-    return botMessages[botMessages.length - 1];
-  }
-
-  /**
-   * Get the current conversation ID
-   */
-  getConversationId(): string {
-    return this.conversationId;
-  }
-
-  /**
-   * Get the port the test server is running on
-   */
-  getPort(): number {
-    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: string,
-    verb: string,
-    data: Record<string, unknown> = {}
-  ): Promise<unknown> {
-    if (!this.started) {
-      throw new Error("TestClient is not started. Call start() first.");
-    }
-
-    const port = this.serverManager.port;
-    const meId = 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: string, data: Record<string, unknown>): Promise<unknown> {
-    if (!this.started) {
-      throw new Error("TestClient is not started. Call start() first.");
-    }
-
-    const port = this.serverManager.port;
-    const meId = 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
-   */
-  private registerUniqueConversation(): void {
-    const chatType = this.config.chatType ?? "personal";
-    const chatManager = Factory.getChatManager();
-    const conversationManager = Factory.getConversationManager();
-
-    if (chatType === "group") {
-      const chat = chatManager.createGroupChat(`test-group-${Date.now()}`);
-      const conversation = conversationManager.createConversation(chat);
-      this.conversationId = conversation.id;
-      this.userId = Factory.getTenantManager().getMe().id;
-    } else if (chatType === "channel") {
-      const teamManager = Factory.getTeamManager();
-      const channel = teamManager.getGeneralChannel();
-      const conversation = conversationManager.createConversation(channel);
-      this.conversationId = conversation.id;
-      this.userId = 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 = Factory.getTenantManager().getMe().id;
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-call
-      (chatManager as any)._chatUsers.set(chat.id, new Set([meId]));
-    }
-  }
-
-  /**
-   * Convert a Message to a BotResponse
-   */
-  private toBotResponse(message: Message): BotResponse {
-    return {
-      messageId: message.content.id,
-      text: message.content.text,
-      attachments: message.content.attachments,
-      timestamp: message.content.timestamp.getTime(),
-      raw: message,
-    };
-  }
-}

package/src/types.ts

@@ -1,155 +0,0 @@
-import { AccountRole } from "schema";
-import { Message } from "server";
-import type { Attachment } from "server";
-
-// Re-export action types for consumers
-export { ActionType, LogActionType } from "schema";
-export type {
-  IAction,
-  ICreateMessageAction,
-  IUpdateMessageAction,
-  ITypingAction,
-  IActionMessage,
-  // Log action types
-  ILogAction,
-  IAppendLogAction,
-  LogItem,
-} from "schema";
-
-/**
- * Bot configuration matching the .m365agentsplayground.yml format
- */
-export interface BotConfig {
-  /**
-   * Bot's unique identifier
-   */
-  id: string;
-
-  /**
-   * Bot display name (max 42 characters)
-   */
-  name: string;
-
-  /**
-   * User ID for agentic-role bots
-   */
-  agenticUserId?: string;
-
-  /**
-   * App ID for agentic-role bots
-   */
-  agenticAppId?: string;
-
-  /**
-   * Bot's tenant ID (defaults to root tenant)
-   */
-  tenantId?: string;
-
-  /**
-   * Bot role: "user" | "bot" | "agenticUser"
-   */
-  role?: AccountRole;
-}
-
-/**
- * Configuration for the TestClient
- */
-export interface TestClientConfig {
-  /**
-   * The bot endpoint URL (e.g., "http://localhost:3978/api/messages")
-   */
-  botEndpoint: string;
-
-  /**
-   * Timeout in milliseconds for waiting for bot responses.
-   * Default: 5000
-   */
-  timeout?: number;
-
-  /**
-   * Port to run the test server on.
-   * Default: auto-assigned
-   */
-  port?: number;
-
-  /**
-   * Bot configuration (id, name, role, etc.)
-   * If not provided, uses default bot config.
-   */
-  bot?: BotConfig;
-
-  /**
-   * Chat type to use when sending messages.
-   * - "personal": 1:1 personal chat with the bot (default)
-   * - "group": group chat context
-   * - "channel": team channel context
-   */
-  chatType?: "personal" | "group" | "channel";
-
-  /**
-   * Delivery mode for activities sent to the bot.
-   * - "expectReplies": Bot responses come inline in the HTTP response.
-   * - "default": Bot posts responses back to the connector URL.
-   */
-  deliveryMode?: "expectReplies" | "default";
-
-  /**
-   * Quiet-period fallback (ms) for streaming bot responses.
-   *
-   * When the simulator detects a streaming placeholder (`"Loading stream results..."`),
-   * it first waits for a `streamType:"final"` WebSocket event (the precise end-of-stream
-   * signal sent by teams-ai / teams.ts SDK). If no `streamType:"final"` arrives, it falls
-   * back to a quiet-period: resolves after this many milliseconds with no new
-   * `updateActivity` events.
-   *
-   * Default: 800 ms. Has no effect for bots with `stream: false`.
-   *
-   * @example
-   * // Increase for slow LLMs
-   * const client = new TestClient({
-   *   botEndpoint: "http://localhost:3978/api/messages",
-   *   streamingSettleDelayMs: 2000,
-   * });
-   */
-  streamingSettleDelayMs?: number;
-}
-
-/**
- * A response from the bot
- */
-export interface BotResponse {
-  /**
-   * The unique message ID
-   */
-  messageId: string;
-
-  /**
-   * The text content of the response
-   */
-  text?: string;
-
-  /**
-   * Attachments in the response (e.g., Adaptive Cards)
-   */
-  attachments?: Attachment[];
-
-  /**
-   * Timestamp when the message was created
-   */
-  timestamp: number;
-
-  /**
-   * The raw Message object from ConversationManager
-   */
-  raw: Message;
-}
-
-/**
- * Promise handlers for async response waiting
- */
-export interface PendingResponse {
-  resolve: (messages: Message[]) => void;
-  reject: (error: Error) => void;
-  timer: NodeJS.Timeout;
-  messageCountBefore: number;
-}