@microsoft/m365agentsplayground-cli 0.2.26 → 0.2.27-alpha.20260518-462fbee.0

package/build/responseCapture.js

@@ -1,119 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResponseCapture = void 0;
-/**
- * Captures bot responses by hooking into BotConnectorService.processActivity
- */
-class ResponseCapture {
-    pendingResponses = new Map();
-    originalProcessActivity;
-    /**
-     * Hook into BotConnectorService to intercept responses
-     */
-    hookIntoBotConnectorService(service) {
-        if (this.originalProcessActivity) {
-            // Already hooked
-            return;
-        }
-        this.originalProcessActivity = service.processActivity.bind(service);
-        service.processActivity = async (conversationId, activity) => {
-            if (this.originalProcessActivity === undefined) {
-                throw new Error("BotConnectorService.processActivity is undefined");
-            }
-            try {
-                const result = await this.originalProcessActivity(conversationId, activity);
-                // Only resolve waiting when an actual message was created (resIds non-empty).
-                // Typing indicators and trace activities return resIds:[] and must NOT
-                // resolve the waiting promise prematurely.
-                if (result.resIds.length > 0) {
-                    this.resolveWaiting(conversationId);
-                }
-                return result;
-            }
-            catch (error) {
-                // Log the error for debugging — this is the actual error that causes 500s
-                // when the bot POSTs back to the connector.
-                console.error(`[ResponseCapture] processActivity error for conversation ${conversationId}:`, error);
-                const activityAny = activity;
-                const entities = Array.isArray(activityAny.entities) ? activityAny.entities : [];
-                console.error(`[ResponseCapture] Activity type: ${String(activityAny.type)}, ` +
-                    `entities: ${JSON.stringify(entities.map((e) => e.type))}`);
-                // Still resolve waiting on error — the test should see whatever messages
-                // were created before the error, rather than timing out silently.
-                this.resolveWaiting(conversationId);
-                throw error;
-            }
-        };
-    }
-    /**
-     * Wait for a response in the given conversation
-     */
-    async waitForResponse(conversationId, conversationManager, timeout) {
-        const messageCountBefore = conversationManager.listMessages(conversationId).length;
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                this.pendingResponses.delete(conversationId);
-                // Check one more time before rejecting
-                const messages = conversationManager.listMessages(conversationId);
-                const newMessages = messages.slice(messageCountBefore);
-                const botMessages = newMessages.filter((m) => m.createdBy === "bot");
-                if (botMessages.length > 0) {
-                    resolve(botMessages);
-                }
-                else {
-                    reject(new Error(`Timeout waiting for bot response after ${timeout}ms`));
-                }
-            }, timeout);
-            this.pendingResponses.set(conversationId, {
-                resolve: (messages) => {
-                    clearTimeout(timer);
-                    resolve(messages);
-                },
-                reject,
-                timer,
-                messageCountBefore,
-            });
-        });
-    }
-    /**
-     * Resolve waiting promises when a response arrives
-     */
-    resolveWaiting(conversationId) {
-        const pending = this.pendingResponses.get(conversationId);
-        if (!pending) {
-            return;
-        }
-        // Use setImmediate to allow the message to be stored first
-        setImmediate(() => {
-            // The pending might have been removed by timeout
-            if (!this.pendingResponses.has(conversationId)) {
-                return;
-            }
-            // We don't have direct access to conversationManager here,
-            // so we just signal completion. The TestClient will check for new messages.
-            this.pendingResponses.delete(conversationId);
-            clearTimeout(pending.timer);
-            pending.resolve([]);
-        });
-    }
-    /**
-     * Clear all pending responses
-     */
-    clear() {
-        this.pendingResponses.forEach((pending) => {
-            clearTimeout(pending.timer);
-        });
-        this.pendingResponses.clear();
-    }
-    /**
-     * Clear pending responses for a specific conversation only
-     */
-    clearConversation(conversationId) {
-        const pending = this.pendingResponses.get(conversationId);
-        if (pending) {
-            clearTimeout(pending.timer);
-            this.pendingResponses.delete(conversationId);
-        }
-    }
-}
-exports.ResponseCapture = ResponseCapture;

package/build/runConversation.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"runConversation.d.ts","sourceRoot":"","sources":["../src/runConversation.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,KAAK,EACV,SAAS,EAET,iBAAiB,EAIjB,kBAAkB,EACnB,MAAM,qBAAqB,CAAC;AAM7B,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAErC;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAE1C;AAoHD;;;;;GAKG;AACH,wBAAsB,eAAe,CACnC,MAAM,EAAE,SAAS,EACjB,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,kBAAkB,CAAC,CA+N7B"}

package/build/runConversation.js

@@ -1,351 +0,0 @@
-"use strict";
-/**
- * Conversation execution logic for the test harness.
- *
- * Runs a sequence of turns against a bot through a fresh TestClient
- * and returns the bot's responses. No eval logic — just execution.
- */
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || (function () {
-    var ownKeys = function(o) {
-        ownKeys = Object.getOwnPropertyNames || function (o) {
-            var ar = [];
-            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
-            return ar;
-        };
-        return ownKeys(o);
-    };
-    return function (mod) {
-        if (mod && mod.__esModule) return mod;
-        var result = {};
-        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
-        __setModuleDefault(result, mod);
-        return result;
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.log = log;
-exports.logError = logError;
-exports.runConversation = runConversation;
-const http = __importStar(require("http"));
-const https = __importStar(require("https"));
-const testClient_1 = require("./testClient");
-const notificationSender_1 = require("./notificationSender");
-const cardValidator_1 = require("./cardValidator");
-// ─────────────────────────────────────────────────────────────────────────────
-// Logging (stderr only — stdout is reserved for structured output)
-// ─────────────────────────────────────────────────────────────────────────────
-function log(msg) {
-    process.stderr.write(`[agents-simulator] ${msg}\n`);
-}
-function logError(msg) {
-    process.stderr.write(`[agents-simulator][ERROR] ${msg}\n`);
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Persona resolution
-// ─────────────────────────────────────────────────────────────────────────────
-function resolvePersona(turn, input, config) {
-    const personaName = turn.persona ?? input.persona;
-    if (!personaName || !config.personas)
-        return undefined;
-    const persona = config.personas[personaName];
-    if (!persona) {
-        log(`Warning: persona "${personaName}" not found in config, using default`);
-        return undefined;
-    }
-    return persona;
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Bot auth preflight check
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Send a bare probe request to the bot endpoint (no Authorization header).
- * Returns the HTTP status code, or throws if the bot is unreachable.
- *
- * Bot Framework SDK behaviour:
- *   - MicrosoftAppId is empty → anonymous mode → accepts any request → 200/202
- *   - MicrosoftAppId is set   → validates JWT → rejects bare request → 401
- */
-async function probeBot(botEndpoint) {
-    return new Promise((resolve, reject) => {
-        const url = new URL(botEndpoint);
-        const lib = url.protocol === "https:" ? https : http;
-        // Use type:"typing" — the Bot Framework adapter acks it immediately without
-        // invoking the AI planner (no LLM call, no sendActivity, instant response).
-        // Bot returns 200/202 for unauthenticated bots, 401 for authenticated ones.
-        const body = JSON.stringify({ type: "typing" });
-        const req = lib.request({
-            hostname: url.hostname,
-            port: url.port || (url.protocol === "https:" ? 443 : 80),
-            path: url.pathname,
-            method: "POST",
-            headers: {
-                "Content-Type": "application/json",
-                "Content-Length": Buffer.byteLength(body),
-            },
-        }, (res) => resolve(res.statusCode ?? 0));
-        req.on("error", reject);
-        req.setTimeout(5000, () => {
-            req.destroy(new Error(`Connection to bot timed out: ${botEndpoint}`));
-        });
-        req.write(body);
-        req.end();
-    });
-}
-/**
- * Verify the bot is reachable and accepting unauthenticated requests.
- * Throws a descriptive error when the bot returns 401 or is unreachable.
- */
-async function checkBotReachable(botEndpoint) {
-    let statusCode;
-    try {
-        statusCode = await probeBot(botEndpoint);
-    }
-    catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        throw new Error(`Cannot reach bot at ${botEndpoint}: ${msg}\n` +
-            `  → Make sure the bot is running before starting a conversation.`);
-    }
-    if (statusCode === 401) {
-        throw new Error(`Bot at ${botEndpoint} requires authentication (HTTP 401).\n` +
-            `  → For local testing, start the bot with BOT_ID="" BOT_PASSWORD="" so it\n` +
-            `    accepts requests without a Bot Framework JWT token.\n` +
-            `  → Example: BOT_ID= BOT_PASSWORD= node ./src/index.ts`);
-    }
-}
-// ─────────────────────────────────────────────────────────────────────────────
-// Conversation execution
-// ─────────────────────────────────────────────────────────────────────────────
-/**
- * Extract and validate Adaptive Card attachments from bot responses.
- * Only processes "application/vnd.microsoft.card.adaptive" attachments.
- */
-function extractAttachments(responses) {
-    const result = [];
-    for (const r of responses) {
-        for (const att of r.attachments ?? []) {
-            if (att.contentType === "application/vnd.microsoft.card.adaptive" && att.content) {
-                const content = att.content;
-                const card_errors = (0, cardValidator_1.validateAdaptiveCard)(content);
-                result.push({ contentType: att.contentType, content, card_errors });
-            }
-        }
-    }
-    return result;
-}
-/**
- * Run a single conversation through a fresh TestClient.
- *
- * Creates an isolated TestClient, sends each turn sequentially, and
- * collects the bot's responses. On failure, remaining turns are skipped.
- */
-async function runConversation(config, scenario, input) {
-    const results = [];
-    const convStart = Date.now();
-    const timeout = config.timeout ?? 120000;
-    const turns = input.turns || [];
-    if (turns.length === 0) {
-        return {
-            type: "conversation_result",
-            scenario,
-            status: "Errored",
-            duration_seconds: 0,
-            turns: [],
-        };
-    }
-    // Preflight: verify the bot is reachable and not requiring auth before
-    // spending timeout budget on the first real turn.
-    try {
-        await checkBotReachable(config.botEndpoint);
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logError(message);
-        return {
-            type: "conversation_result",
-            scenario,
-            status: "Errored",
-            duration_seconds: (Date.now() - convStart) / 1000,
-            turns: turns.map((t) => ({
-                test_id: t.test_id,
-                prompt: t.prompt,
-                actual_response: null,
-                attachments: [],
-                status: "Errored",
-                error_message: message,
-                duration_seconds: 0,
-            })),
-        };
-    }
-    const client = new testClient_1.TestClient({
-        botEndpoint: config.botEndpoint,
-        timeout,
-        bot: config.bot,
-        deliveryMode: config.deliveryMode ?? "expectReplies",
-        chatType: config.chatType ?? "personal",
-        streamingSettleDelayMs: config.streamingSettleDelayMs ?? 0,
-    });
-    try {
-        log(`Starting client for: ${scenario}`);
-        await client.start();
-        log(`Client started on port ${client.getPort()}`);
-        // Maps turn test_id → messageId of the bot's first card response in that turn
-        const cardMessageIds = new Map();
-        for (let i = 0; i < turns.length; i++) {
-            const turn = turns[i];
-            const turnType = turn.turn_type ?? "chat";
-            const turnStart = Date.now();
-            log(`  Turn ${i + 1}/${turns.length} [${turn.test_id}] (${turnType}): ${turn.prompt.substring(0, 80)}...`);
-            try {
-                let responseText;
-                let attachments = [];
-                if (turnType === "chat") {
-                    const responses = await client.sendMessage(turn.prompt);
-                    responseText = responses
-                        .map((r) => r.text ?? "")
-                        .filter((t) => t.length > 0)
-                        .join("\n\n");
-                    attachments = extractAttachments(responses);
-                    // Track the first card-containing message ID for card_action turns
-                    const firstCardMsg = responses.find((r) => r.attachments?.some((a) => a.contentType === "application/vnd.microsoft.card.adaptive"));
-                    if (firstCardMsg?.messageId) {
-                        cardMessageIds.set(turn.test_id, firstCardMsg.messageId);
-                    }
-                }
-                else if (turnType === "card_action") {
-                    const cardAction = turn.card_action;
-                    if (!cardAction) {
-                        throw new Error(`Turn "${turn.test_id}" has turn_type "card_action" but no card_action field.`);
-                    }
-                    if (!cardAction.verb) {
-                        throw new Error(`Turn "${turn.test_id}" card_action is missing required "verb" field.`);
-                    }
-                    // Resolve the target message ID from the referenced turn
-                    let replyToId;
-                    if (cardAction.reply_to_turn != null) {
-                        replyToId = cardMessageIds.get(cardAction.reply_to_turn);
-                        if (!replyToId) {
-                            throw new Error(`card_action.reply_to_turn "${cardAction.reply_to_turn}" did not produce a card message. ` +
-                                `Ensure that turn sends a card before using card_action.`);
-                        }
-                    }
-                    else {
-                        // Use the most recently stored card messageId
-                        const entries = [...cardMessageIds.values()];
-                        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
-                        replyToId = entries[entries.length - 1];
-                    }
-                    if (!replyToId) {
-                        throw new Error(`card_action for turn "${turn.test_id}" could not find any card message to target. ` +
-                            `Ensure a prior turn produces an Adaptive Card.`);
-                    }
-                    if (cardAction.action_type === "Action.Submit") {
-                        const invokeResponse = await client.submitCardForm(replyToId, cardAction.data ?? {});
-                        responseText = JSON.stringify(invokeResponse);
-                    }
-                    else {
-                        const invokeResponse = await client.clickCardButton(replyToId, cardAction.verb, cardAction.data ?? {});
-                        responseText = JSON.stringify(invokeResponse);
-                    }
-                }
-                else {
-                    const persona = resolvePersona(turn, input, config);
-                    responseText = await (0, notificationSender_1.sendNotificationAndWait)(client.getConversationId(), turn, persona, timeout);
-                }
-                const duration = (Date.now() - turnStart) / 1000;
-                log(`  [OK] (${duration.toFixed(1)}s): ${responseText.substring(0, 100)}...`);
-                results.push({
-                    test_id: turn.test_id,
-                    prompt: turn.prompt,
-                    actual_response: responseText || null,
-                    attachments,
-                    status: "Completed",
-                    duration_seconds: duration,
-                });
-            }
-            catch (err) {
-                const duration = (Date.now() - turnStart) / 1000;
-                const message = err instanceof Error ? err.message : String(err);
-                const isTimeout = message.includes("Timeout");
-                logError(`  Turn ${turn.test_id} failed: ${message}`);
-                results.push({
-                    test_id: turn.test_id,
-                    prompt: turn.prompt,
-                    actual_response: null,
-                    attachments: [],
-                    status: isTimeout ? "TimedOut" : "Errored",
-                    error_message: message,
-                    duration_seconds: duration,
-                });
-                for (let j = i + 1; j < turns.length; j++) {
-                    results.push({
-                        test_id: turns[j].test_id,
-                        prompt: turns[j].prompt,
-                        actual_response: null,
-                        attachments: [],
-                        status: "Skipped",
-                        duration_seconds: 0,
-                    });
-                }
-                break;
-            }
-        }
-    }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logError(`Client startup failed for ${scenario}: ${message}`);
-        for (const turn of turns) {
-            results.push({
-                test_id: turn.test_id,
-                prompt: turn.prompt,
-                actual_response: null,
-                attachments: [],
-                status: "Errored",
-                error_message: message,
-                duration_seconds: 0,
-            });
-        }
-    }
-    finally {
-        try {
-            await client.stop();
-        }
-        catch {
-            // Ignore stop errors.
-        }
-    }
-    const convDuration = (Date.now() - convStart) / 1000;
-    const statuses = new Set(results.map((t) => t.status));
-    let overallStatus;
-    if (statuses.has("TimedOut")) {
-        overallStatus = "TimedOut";
-    }
-    else if (statuses.has("Errored")) {
-        overallStatus = "Errored";
-    }
-    else {
-        overallStatus = "Completed";
-    }
-    return {
-        type: "conversation_result",
-        scenario,
-        status: overallStatus,
-        duration_seconds: convDuration,
-        turns: results,
-    };
-}

package/build/serverManager.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"serverManager.d.ts","sourceRoot":"","sources":["../src/serverManager.ts"],"names":[],"mappings":"AAGA,OAAO,EAAgB,OAAO,EAAiB,MAAM,QAAQ,CAAC;AAE9D,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AACpD,OAAO,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAiB3C,qBAAa,aAAa;IAExB,OAAO,CAAC,MAAM,CAAC,MAAM,CAAuB;IAC5C,OAAO,CAAC,MAAM,CAAC,GAAG,CAAwB;IAC1C,OAAO,CAAC,MAAM,CAAC,KAAK,CAAK;IACzB,OAAO,CAAC,MAAM,CAAC,WAAW,CAAM;IAChC,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAS;IAChC,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAgC;IAE/D;;;;;OAKG;IACG,KAAK,CAAC,MAAM,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC;IAyFpD;;;;;;;;OAQG;IACG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAI3B;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAED;;OAEG;IACH,UAAU,IAAI,OAAO,OAAO;IAI5B;;;OAGG;IACH,MAAM,CAAC,kBAAkB,IAAI,eAAe;CAM7C"}

package/build/serverManager.js

@@ -1,149 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServerManager = void 0;
-const express_1 = __importDefault(require("express"));
-const server_1 = require("server");
-const schema_1 = require("schema");
-const responseCapture_1 = require("./responseCapture");
-/**
- * Manages the shared Express server lifecycle for the test harness.
- *
- * The server package's Factory is a process-wide singleton — calling
- * mountBackend() more than once replaces ConfigManager while leaving
- * every other cached manager/service stale. ServerManager therefore
- * starts the Express server exactly once and reuses it for all
- * TestClient instances in the same process.
- */
-// Fixed conversation ID used only for the initial ConfigManager bootstrap.
-// Individual TestClients register their own unique conversations in
-// ConversationManager (see TestClient.registerUniqueConversation).
-const BOOTSTRAP_CONVERSATION_ID = "playground-cli-bootstrap";
-class ServerManager {
-    // ── Shared process-level state ───────────────────────────────────────
-    static server = null;
-    static app = null;
-    static _port = 0;
-    static _serviceUrl = "";
-    static _started = false;
-    static _responseCapture = null;
-    /**
-     * Start the shared test server (no-op if already running).
-     *
-     * The first call boots Express + mountBackend. Subsequent calls
-     * return immediately, reusing the existing server.
-     */
-    async start(config) {
-        if (ServerManager._started) {
-            return;
-        }
-        const app = (0, express_1.default)();
-        ServerManager.app = app;
-        // Create HTTP server first
-        ServerManager.server = app.listen(config.port ?? 0);
-        // Wait for server to be listening
-        await new Promise((resolve, reject) => {
-            ServerManager.server?.once("listening", resolve);
-            ServerManager.server?.once("error", reject);
-        });
-        // Get the assigned port
-        const address = ServerManager.server?.address();
-        ServerManager._port = address.port;
-        ServerManager._serviceUrl = `http://localhost:${ServerManager._port}/_connector`;
-        // Get default config and merge bot config if provided
-        const defaultConfig = server_1.ConfigManager.getDefaultConfig({
-            path: "",
-            conversationId: BOOTSTRAP_CONVERSATION_ID,
-        });
-        if (config.bot) {
-            defaultConfig.bot = {
-                ...defaultConfig.bot,
-                ...config.bot,
-            };
-            // Also update the root tenantId if bot.tenantId is provided
-            if (config.bot.tenantId) {
-                defaultConfig.tenantId = config.bot.tenantId;
-            }
-        }
-        if (!ServerManager.server) {
-            throw new Error("Server failed to start");
-        }
-        // Map delivery mode string to enum value
-        const deliveryMode = config.deliveryMode === "expectReplies"
-            ? schema_1.DeliveryMode.ExpectReplies
-            : config.deliveryMode === "default"
-                ? schema_1.DeliveryMode.Default
-                : undefined;
-        (0, server_1.mountBackend)(app, ServerManager.server, {
-            configFileOptions: { configFile: defaultConfig },
-            appConfig: {
-                endpoint: config.botEndpoint,
-            },
-            debugConfig: {
-                eventsRecordingEnabled: false,
-                deliveryMode,
-            },
-        });
-        // Add error-handling middleware for connector routes.
-        app.use((err, _req, res, 
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        _next) => {
-            console.error("[agents-simulator] Unhandled error in connector:", err);
-            if (!res.headersSent) {
-                res.status(500).json({
-                    error: {
-                        code: "InternalError",
-                        message: err.message || "Unknown error",
-                    },
-                });
-            }
-        });
-        // Hook the shared ResponseCapture into BotConnectorService once.
-        const capture = ServerManager.getResponseCapture();
-        capture.hookIntoBotConnectorService(server_1.Factory.getBotConnectorService());
-        ServerManager._started = true;
-    }
-    /**
-     * No-op — the shared server stays running for the process lifetime.
-     *
-     * Per-client cleanup (WebSockets, conversation messages) is handled
-     * by TestClient.stop().
-     *
-     * TODO(server-package): Add a Factory.reset() so the harness can
-     * fully tear down between test suites if needed.
-     */
-    async stop() {
-        // Intentionally empty.
-    }
-    /**
-     * Get the port the server is running on
-     */
-    get port() {
-        return ServerManager._port;
-    }
-    /**
-     * Get the service URL for the connector API
-     */
-    get serviceUrl() {
-        return ServerManager._serviceUrl;
-    }
-    /**
-     * Get the Factory instance for accessing services
-     */
-    getFactory() {
-        return server_1.Factory;
-    }
-    /**
-     * Shared ResponseCapture instance — keyed by conversationId, so
-     * concurrent TestClients don't interfere with each other.
-     */
-    static getResponseCapture() {
-        if (!ServerManager._responseCapture) {
-            ServerManager._responseCapture = new responseCapture_1.ResponseCapture();
-        }
-        return ServerManager._responseCapture;
-    }
-}
-exports.ServerManager = ServerManager;

package/build/start-server.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"start-server.d.ts","sourceRoot":"","sources":["../src/start-server.ts"],"names":[],"mappings":";AAEA;;;;;GAKG"}

package/build/start-server.js

@@ -1,23 +0,0 @@
-#!/usr/bin/env node
-"use strict";
-/**
- * Starts the Conversation Server.
- *
- * Usage:
- *   node build/start-server.js [--port <port>]
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-const conversationServer_1 = require("./conversationServer");
-function parsePort() {
-    const args = process.argv.slice(2);
-    for (let i = 0; i < args.length; i++) {
-        if (args[i] === "--port" && args[i + 1]) {
-            return parseInt(args[++i], 10);
-        }
-    }
-    return 0;
-}
-const port = parsePort();
-void (0, conversationServer_1.createConversationServer)({ port }).then((server) => {
-    process.stdout.write(JSON.stringify({ port: server.port }) + "\n");
-});

package/build/testClient.d.ts.map

@@ -1 +0,0 @@
-{"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,CAAC,SAAS,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC;IA4BxF;;;;;OAKG;IACH,OAAO,CAAC,0BAA0B;IAiClC;;OAEG;IACH,OAAO,CAAC,aAAa;CAStB"}