@wingman-ai/gateway 0.4.1 → 0.4.3

package/dist/cli/types.d.ts

@@ -66,6 +66,24 @@ export interface WingmanConfig {
                 gatewayPassword?: string;
                 responseChunkSize?: number;
             };
+            teams?: {
+                enabled?: boolean;
+                appId?: string;
+                appPassword?: string;
+                appType?: "MultiTenant" | "SingleTenant" | "UserAssignedMsi" | "UserAssignedMSI";
+                tenantId?: string;
+                endpointPath?: string;
+                mentionOnly?: boolean;
+                allowBots?: boolean;
+                allowedTeamIds?: string[];
+                allowedChannelIds?: string[];
+                channelSessions?: Record<string, string>;
+                sessionCommand?: string;
+                gatewayUrl?: string;
+                gatewayToken?: string;
+                gatewayPassword?: string;
+                responseChunkSize?: number;
+            };
         };
     };
     agents?: {

package/dist/gateway/adapters/teams.cjs

@@ -0,0 +1,419 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    TeamsGatewayAdapter: ()=>TeamsGatewayAdapter,
+    normalizeTeamsEndpointPath: ()=>normalizeTeamsEndpointPath,
+    isTeamsBotMentioned: ()=>isTeamsBotMentioned,
+    resolveTeamsChannelSessionKey: ()=>resolveTeamsChannelSessionKey,
+    splitTeamsMessage: ()=>splitTeamsMessage,
+    extractTeamsMentionTexts: ()=>extractTeamsMentionTexts,
+    DEFAULT_TEAMS_RESPONSE_CHUNK: ()=>DEFAULT_TEAMS_RESPONSE_CHUNK,
+    DEFAULT_TEAMS_ENDPOINT_PATH: ()=>DEFAULT_TEAMS_ENDPOINT_PATH,
+    stripTeamsBotMention: ()=>stripTeamsBotMention
+});
+const external_botbuilder_namespaceObject = require("botbuilder");
+const streamParser_cjs_namespaceObject = require("../../cli/core/streamParser.cjs");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const external_rpcClient_cjs_namespaceObject = require("../rpcClient.cjs");
+const external_discord_cjs_namespaceObject = require("./discord.cjs");
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+const DEFAULT_TEAMS_ENDPOINT_PATH = "/api/adapters/teams/messages";
+const DEFAULT_TEAMS_RESPONSE_CHUNK = 3500;
+function normalizeTeamsEndpointPath(path) {
+    const fallback = DEFAULT_TEAMS_ENDPOINT_PATH;
+    if (!path || "string" != typeof path) return fallback;
+    const trimmed = path.trim();
+    if (!trimmed) return fallback;
+    return trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+}
+function splitTeamsMessage(text, maxLength = DEFAULT_TEAMS_RESPONSE_CHUNK) {
+    const normalized = text.trim();
+    if (!normalized) return [];
+    const chunks = [];
+    let current = "";
+    for (const char of normalized){
+        if (current.length + 1 > maxLength) {
+            chunks.push(current);
+            current = "";
+        }
+        current += char;
+    }
+    if (current) chunks.push(current);
+    return chunks;
+}
+function escapeRegex(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function getEntities(activity) {
+    if (!Array.isArray(activity.entities)) return [];
+    return activity.entities;
+}
+function extractTeamsMentionTexts(activity, botAccountId) {
+    const recipientName = activity.recipient?.name?.trim().toLowerCase();
+    const texts = new Set();
+    for (const entity of getEntities(activity)){
+        if ("mention" !== entity.type || "string" != typeof entity.text) continue;
+        const mentionedId = entity.mentioned?.id?.trim();
+        const mentionedName = entity.mentioned?.name?.trim().toLowerCase();
+        if (botAccountId && mentionedId === botAccountId || recipientName && mentionedName === recipientName) texts.add(entity.text);
+    }
+    return Array.from(texts);
+}
+function stripTeamsBotMention(content, mentionTexts = []) {
+    if (!content) return content;
+    let next = content;
+    for (const text of mentionTexts)next = next.replace(new RegExp(escapeRegex(text), "gi"), " ");
+    return next.replace(/<at>.*?<\/at>/gi, " ").replace(/\s+/g, " ").trim();
+}
+function isTeamsBotMentioned(activity, botAccountId) {
+    if (extractTeamsMentionTexts(activity, botAccountId).length > 0) return true;
+    const text = activity.text || "";
+    const recipientName = activity.recipient?.name?.trim();
+    if (recipientName) {
+        const regex = new RegExp(`<at>\\s*${escapeRegex(recipientName)}\\s*</at>`, "i");
+        return regex.test(text);
+    }
+    return false;
+}
+function resolveTeamsChannelSessionKey(channelId, channelSessions) {
+    if (!channelSessions) return;
+    return channelSessions[channelId];
+}
+function toHeaderRecord(headers) {
+    const result = {};
+    for (const [key, value] of headers.entries())result[key] = value;
+    if (!result.Authorization && result.authorization) result.Authorization = result.authorization;
+    return result;
+}
+function buildBotBuilderResponse(resolve) {
+    let statusCode = 200;
+    const headers = new Headers();
+    let body;
+    const finalize = (payload)=>{
+        if (void 0 !== payload) if ("string" == typeof payload) body = payload;
+        else {
+            body = JSON.stringify(payload);
+            if (!headers.get("Content-Type")) headers.set("Content-Type", "application/json");
+        }
+        resolve(new Response(body, {
+            status: statusCode,
+            headers
+        }));
+    };
+    return {
+        status (code) {
+            statusCode = code;
+            return this;
+        },
+        header (name, value) {
+            headers.set(name, value);
+            return this;
+        },
+        send (payload) {
+            finalize(payload);
+        },
+        end (payload) {
+            finalize(payload);
+        },
+        socket: {}
+    };
+}
+function extractTeamId(activity) {
+    const raw = activity.channelData?.team?.id;
+    if ("string" == typeof raw && raw.trim()) return raw;
+}
+function extractChannelId(activity) {
+    const channelId = activity.channelData?.channel?.id;
+    if ("string" == typeof channelId && channelId.trim()) return channelId;
+    const conversationId = activity.conversation?.id;
+    if ("string" == typeof conversationId && conversationId.trim()) return conversationId;
+}
+function extractThreadId(activity) {
+    if (activity.replyToId && activity.replyToId.trim()) return activity.replyToId;
+    const conversationId = activity.conversation?.id;
+    if (!conversationId) return;
+    const match = conversationId.match(/;messageid=([^;]+)/i);
+    if (!match?.[1]) return;
+    try {
+        return decodeURIComponent(match[1]);
+    } catch  {
+        return match[1];
+    }
+}
+function isDirectMessage(activity) {
+    return activity.conversation?.conversationType === "personal";
+}
+function buildRoutingInfo(activity, botAccountId) {
+    const routing = {
+        channel: "teams",
+        accountId: botAccountId
+    };
+    const teamId = extractTeamId(activity);
+    if (teamId) routing.teamId = teamId;
+    const conversationType = activity.conversation?.conversationType;
+    if ("personal" === conversationType) {
+        const dmId = activity.from?.aadObjectId || activity.from?.id;
+        if (dmId) routing.peer = {
+            kind: "dm",
+            id: dmId
+        };
+    } else if ("groupChat" === conversationType) {
+        if (activity.conversation?.id) routing.peer = {
+            kind: "group",
+            id: activity.conversation.id
+        };
+    } else {
+        const channelId = extractChannelId(activity);
+        if (channelId) routing.peer = {
+            kind: "channel",
+            id: channelId
+        };
+    }
+    const threadId = extractThreadId(activity);
+    if (threadId) routing.threadId = threadId;
+    return routing;
+}
+function isBotMessage(activity) {
+    return activity.from?.role === "bot";
+}
+class TeamsGatewayAdapter {
+    get endpointPath() {
+        return normalizeTeamsEndpointPath(this.config.endpointPath);
+    }
+    async start() {
+        if (this.started) return;
+        if (!this.config.enabled) return;
+        if (!this.config.appId || !this.config.appPassword) return void this.logger.warn("Teams adapter enabled but Microsoft app credentials are incomplete.");
+        this.gatewayClient = new external_rpcClient_cjs_namespaceObject.GatewayRpcClient(this.gateway.url, {
+            token: this.gateway.token,
+            password: this.gateway.password,
+            clientType: "teams"
+        });
+        await this.gatewayClient.connect();
+        const authConfig = {
+            MicrosoftAppId: this.config.appId,
+            MicrosoftAppPassword: this.config.appPassword,
+            MicrosoftAppType: this.config.appType
+        };
+        if (this.config.tenantId) authConfig.MicrosoftAppTenantId = this.config.tenantId;
+        const authentication = new external_botbuilder_namespaceObject.ConfigurationBotFrameworkAuthentication(authConfig);
+        this.adapter = new external_botbuilder_namespaceObject.CloudAdapter(authentication);
+        this.adapter.onTurnError = async (context, error)=>{
+            this.logger.error("Teams adapter turn error", error);
+            try {
+                await context.sendActivity("Sorry, I hit an error running that request.");
+            } catch  {}
+        };
+        this.started = true;
+    }
+    async stop() {
+        if (!this.started) return;
+        this.started = false;
+        this.adapter = null;
+        if (this.gatewayClient) {
+            this.gatewayClient.disconnect();
+            this.gatewayClient = null;
+        }
+    }
+    async handleHttpRequest(req, url) {
+        if (url.pathname !== this.endpointPath) return null;
+        if ("POST" !== req.method) return new Response("Method Not Allowed", {
+            status: 405,
+            headers: {
+                Allow: "POST"
+            }
+        });
+        if (!this.started || !this.adapter || !this.gatewayClient) return new Response("Teams adapter not started", {
+            status: 503
+        });
+        const adapter = this.adapter;
+        let body;
+        try {
+            body = await req.json();
+        } catch  {
+            return new Response("Invalid JSON payload", {
+                status: 400
+            });
+        }
+        const activity = body;
+        return new Promise((resolve)=>{
+            const response = buildBotBuilderResponse(resolve);
+            adapter.process({
+                method: req.method,
+                headers: toHeaderRecord(req.headers),
+                body: activity
+            }, response, async (context)=>this.handleMessage(context)).catch((error)=>{
+                this.logger.error("Teams adapter failed to process request", error);
+                resolve(new Response("Failed to process Teams request", {
+                    status: 500
+                }));
+            });
+        });
+    }
+    async handleMessage(context) {
+        if (!this.gatewayClient) return;
+        const activity = context.activity;
+        if ("message" !== activity.type) return;
+        if (!activity.text && !activity.attachments?.length) return;
+        if (isBotMessage(activity)) {
+            if (!this.config.allowBots) return;
+            if (activity.from?.id && activity.from.id === activity.recipient?.id) return;
+        }
+        const teamId = extractTeamId(activity);
+        if (this.config.allowedTeamIds.length > 0 && teamId) {
+            if (!this.config.allowedTeamIds.includes(teamId)) return;
+        }
+        const channelId = extractChannelId(activity);
+        if (this.config.allowedChannelIds.length > 0) {
+            if (!channelId || !this.config.allowedChannelIds.includes(channelId)) return;
+        }
+        const botAccountId = activity.recipient?.id || this.config.appId;
+        if (this.config.mentionOnly && !isDirectMessage(activity) && !isTeamsBotMentioned(activity, botAccountId)) return;
+        const mentionTexts = extractTeamsMentionTexts(activity, botAccountId);
+        const cleaned = stripTeamsBotMention(activity.text || "", mentionTexts);
+        const attachments = (activity.attachments || []).map((attachment)=>attachment.contentUrl).filter((url)=>Boolean(url));
+        const attachmentText = attachments.length > 0 ? `\n\nAttachments:\n${attachments.map((url)=>`- ${url}`).join("\n")}` : "";
+        let content = `${cleaned}${attachmentText}`.trim();
+        const { sessionKey, content: nextContent, matched } = (0, external_discord_cjs_namespaceObject.extractSessionOverride)(content, this.config.sessionCommand);
+        let resolvedSessionKey = sessionKey;
+        let usedChannelMapping = false;
+        if (matched) {
+            content = nextContent.trim();
+            if (!sessionKey) return void await context.sendActivity(`Provide a session key after \`${this.config.sessionCommand}\`.`);
+        }
+        if (!matched && channelId) {
+            resolvedSessionKey = resolveTeamsChannelSessionKey(channelId, this.config.channelSessions);
+            usedChannelMapping = Boolean(resolvedSessionKey);
+        }
+        const inferredAgentId = (0, external_discord_cjs_namespaceObject.parseAgentIdFromSessionKey)(resolvedSessionKey);
+        if (usedChannelMapping && !inferredAgentId) this.logger.warn(`Teams channel session mapping for channel ${channelId} does not include an agent prefix. Use "agent:<id>:..." to auto-select an agent.`, {
+            sessionKey: resolvedSessionKey
+        });
+        if (!content) return;
+        const payload = {
+            agentId: inferredAgentId,
+            content,
+            routing: buildRoutingInfo(activity, botAccountId),
+            sessionKey: resolvedSessionKey
+        };
+        try {
+            await context.sendActivity({
+                type: "typing"
+            });
+            let fallbackText = "";
+            let uiFallbackText = "";
+            let uiOnlyDetected = false;
+            const textByMessageId = new Map();
+            const messageOrder = [];
+            await this.gatewayClient.requestAgent(payload, (event)=>{
+                if (!event || "object" != typeof event) return;
+                if ("agent-error" === event.type) {
+                    fallbackText += `\n${event.error || "Agent error"}`;
+                    return;
+                }
+                if ("agent-stream" !== event.type) return;
+                const parsedChunks = (0, streamParser_cjs_namespaceObject.parseStreamChunk)(event.chunk);
+                for (const chunk of parsedChunks){
+                    if ("tool-result" === chunk.type && chunk.toolResult?.output) {
+                        const meta = (0, external_discord_cjs_namespaceObject.extractUiMeta)(chunk.toolResult.output);
+                        if (true === meta.uiOnly) uiOnlyDetected = true;
+                        if (meta.textFallback) uiFallbackText = meta.textFallback;
+                    }
+                    if ("text" === chunk.type && chunk.text) {
+                        if (chunk.messageId) {
+                            if (!textByMessageId.has(chunk.messageId)) {
+                                messageOrder.push(chunk.messageId);
+                                textByMessageId.set(chunk.messageId, chunk.text);
+                                continue;
+                            }
+                            const current = textByMessageId.get(chunk.messageId) || "";
+                            textByMessageId.set(chunk.messageId, chunk.isDelta ? current + chunk.text : chunk.text);
+                            continue;
+                        }
+                        fallbackText += chunk.text;
+                    }
+                }
+            });
+            const orderedText = messageOrder.map((id)=>textByMessageId.get(id)).filter((value)=>Boolean(value)).join("\n\n");
+            let responseText = `${fallbackText}${fallbackText && orderedText ? "\n\n" : ""}${orderedText}`.trim();
+            if (uiFallbackText && (uiOnlyDetected || !responseText)) responseText = uiFallbackText.trim();
+            if (!responseText) return;
+            const chunks = splitTeamsMessage(responseText, this.config.responseChunkSize);
+            for (const chunk of chunks)await context.sendActivity(chunk);
+        } catch (error) {
+            this.logger.error("Teams adapter failed to handle message", error);
+            try {
+                await context.sendActivity("Sorry, I hit an error running that request.");
+            } catch  {}
+        }
+    }
+    constructor(config, gateway, logger){
+        _define_property(this, "config", void 0);
+        _define_property(this, "gateway", void 0);
+        _define_property(this, "adapter", void 0);
+        _define_property(this, "gatewayClient", void 0);
+        _define_property(this, "logger", void 0);
+        _define_property(this, "started", void 0);
+        this.config = config;
+        this.gateway = gateway;
+        this.adapter = null;
+        this.gatewayClient = null;
+        this.started = false;
+        this.logger = logger || (0, external_logger_cjs_namespaceObject.createLogger)();
+    }
+}
+exports.DEFAULT_TEAMS_ENDPOINT_PATH = __webpack_exports__.DEFAULT_TEAMS_ENDPOINT_PATH;
+exports.DEFAULT_TEAMS_RESPONSE_CHUNK = __webpack_exports__.DEFAULT_TEAMS_RESPONSE_CHUNK;
+exports.TeamsGatewayAdapter = __webpack_exports__.TeamsGatewayAdapter;
+exports.extractTeamsMentionTexts = __webpack_exports__.extractTeamsMentionTexts;
+exports.isTeamsBotMentioned = __webpack_exports__.isTeamsBotMentioned;
+exports.normalizeTeamsEndpointPath = __webpack_exports__.normalizeTeamsEndpointPath;
+exports.resolveTeamsChannelSessionKey = __webpack_exports__.resolveTeamsChannelSessionKey;
+exports.splitTeamsMessage = __webpack_exports__.splitTeamsMessage;
+exports.stripTeamsBotMention = __webpack_exports__.stripTeamsBotMention;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_TEAMS_ENDPOINT_PATH",
+    "DEFAULT_TEAMS_RESPONSE_CHUNK",
+    "TeamsGatewayAdapter",
+    "extractTeamsMentionTexts",
+    "isTeamsBotMentioned",
+    "normalizeTeamsEndpointPath",
+    "resolveTeamsChannelSessionKey",
+    "splitTeamsMessage",
+    "stripTeamsBotMention"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/adapters/teams.d.ts

@@ -0,0 +1,47 @@
+import { type Activity } from "botbuilder";
+import { type Logger } from "@/logger.js";
+export interface TeamsAdapterConfig {
+    enabled: boolean;
+    appId?: string;
+    appPassword?: string;
+    appType: "MultiTenant" | "SingleTenant" | "UserAssignedMsi" | "UserAssignedMSI";
+    tenantId?: string;
+    endpointPath: string;
+    mentionOnly: boolean;
+    allowBots: boolean;
+    allowedTeamIds: string[];
+    allowedChannelIds: string[];
+    channelSessions?: Record<string, string>;
+    sessionCommand: string;
+    gatewayUrl?: string;
+    gatewayToken?: string;
+    gatewayPassword?: string;
+    responseChunkSize: number;
+}
+export interface TeamsAdapterGatewayConfig {
+    url: string;
+    token?: string;
+    password?: string;
+}
+export declare const DEFAULT_TEAMS_ENDPOINT_PATH = "/api/adapters/teams/messages";
+export declare const DEFAULT_TEAMS_RESPONSE_CHUNK = 3500;
+export declare function normalizeTeamsEndpointPath(path: string | undefined): string;
+export declare function splitTeamsMessage(text: string, maxLength?: number): string[];
+export declare function extractTeamsMentionTexts(activity: Activity, botAccountId?: string): string[];
+export declare function stripTeamsBotMention(content: string, mentionTexts?: string[]): string;
+export declare function isTeamsBotMentioned(activity: Activity, botAccountId?: string): boolean;
+export declare function resolveTeamsChannelSessionKey(channelId: string, channelSessions?: Record<string, string>): string | undefined;
+export declare class TeamsGatewayAdapter {
+    private config;
+    private gateway;
+    private adapter;
+    private gatewayClient;
+    private logger;
+    private started;
+    constructor(config: TeamsAdapterConfig, gateway: TeamsAdapterGatewayConfig, logger?: Logger);
+    get endpointPath(): string;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    handleHttpRequest(req: Request, url: URL): Promise<Response | null>;
+    private handleMessage;
+}