@wingman-ai/gateway 0.4.2 → 0.4.3

package/dist/gateway/adapters/teams.js

@@ -0,0 +1,361 @@
+import { CloudAdapter, ConfigurationBotFrameworkAuthentication } from "botbuilder";
+import { parseStreamChunk } from "../../cli/core/streamParser.js";
+import { createLogger } from "../../logger.js";
+import { GatewayRpcClient } from "../rpcClient.js";
+import { extractSessionOverride, extractUiMeta, parseAgentIdFromSessionKey } from "./discord.js";
+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 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 ConfigurationBotFrameworkAuthentication(authConfig);
+        this.adapter = new 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 } = 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 = 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 = parseStreamChunk(event.chunk);
+                for (const chunk of parsedChunks){
+                    if ("tool-result" === chunk.type && chunk.toolResult?.output) {
+                        const meta = 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 || createLogger();
+    }
+}
+export { DEFAULT_TEAMS_ENDPOINT_PATH, DEFAULT_TEAMS_RESPONSE_CHUNK, TeamsGatewayAdapter, extractTeamsMentionTexts, isTeamsBotMentioned, normalizeTeamsEndpointPath, resolveTeamsChannelSessionKey, splitTeamsMessage, stripTeamsBotMention };

package/dist/gateway/http/sms.cjs

@@ -0,0 +1,286 @@
+"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__, {
+    handleSmsApi: ()=>handleSmsApi,
+    createSmsPolicyStateStore: ()=>createSmsPolicyStateStore
+});
+const control_cjs_namespaceObject = require("../sms/control.cjs");
+const policyStore_cjs_namespaceObject = require("../sms/policyStore.cjs");
+const MAX_PAUSE_FOR_MS = 2592000000;
+const createSmsPolicyStateStore = (resolveConfigDirPath)=>(0, policyStore_cjs_namespaceObject.createSmsPolicyStore)(resolveConfigDirPath);
+function decodeTarget(raw) {
+    let decoded = "";
+    try {
+        decoded = decodeURIComponent(raw);
+    } catch  {
+        return null;
+    }
+    return (0, policyStore_cjs_namespaceObject.normalizeSmsPolicyTarget)(decoded);
+}
+function parsePauseForMs(raw) {
+    if ("number" != typeof raw || !Number.isFinite(raw)) return null;
+    const value = Math.trunc(raw);
+    if (value <= 0 || value > MAX_PAUSE_FOR_MS) return null;
+    return value;
+}
+function toResponsePayload(resolution, nowMs) {
+    return {
+        ...resolution,
+        policy: {
+            ...resolution.policy,
+            pauseExpiresInMs: resolution.policy.paused && resolution.policy.pausedUntil ? Math.max(resolution.policy.pausedUntil - nowMs, 0) : null
+        }
+    };
+}
+function parseRoutingTarget(rawTarget) {
+    const trimmed = rawTarget.trim();
+    if (!trimmed) return null;
+    const normalized = (0, policyStore_cjs_namespaceObject.normalizeSmsPolicyTarget)(trimmed);
+    if (!normalized) return null;
+    const separatorIndex = normalized.indexOf(":");
+    let channel = "sms-macos";
+    let peerId = normalized;
+    if (separatorIndex > 0 && separatorIndex < normalized.length - 1) {
+        const candidateChannel = normalized.slice(0, separatorIndex).trim();
+        const candidatePeer = normalized.slice(separatorIndex + 1).trim();
+        if (candidateChannel && candidatePeer) {
+            channel = candidateChannel;
+            peerId = candidatePeer;
+        }
+    }
+    return {
+        normalizedTarget: normalized,
+        routing: {
+            channel,
+            peer: {
+                kind: "dm",
+                id: peerId
+            }
+        }
+    };
+}
+const handleSmsApi = async (ctx, store, req, url)=>{
+    if ("/api/sms/messages" === url.pathname) {
+        if ("POST" !== req.method) return new Response("Method Not Allowed", {
+            status: 405
+        });
+        let body;
+        try {
+            body = await req.json();
+        } catch  {
+            return new Response("Invalid JSON body", {
+                status: 400
+            });
+        }
+        const parsed = parseRoutingTarget("string" == typeof body.target ? body.target : "");
+        if (!parsed) return new Response("valid target required", {
+            status: 400
+        });
+        const nowMs = Date.now();
+        const text = "string" == typeof body.text ? body.text : "";
+        const control = (0, control_cjs_namespaceObject.applySmsControlCommand)({
+            store,
+            target: parsed.normalizedTarget,
+            text,
+            nowMs
+        });
+        if (control.handled) return new Response(JSON.stringify({
+            kind: "command",
+            ...toResponsePayload(control, nowMs)
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+        if (!control.passThroughText.trim()) return new Response("text required", {
+            status: 400
+        });
+        if (control.policy.stopEnabled) return new Response(JSON.stringify({
+            kind: "stopped",
+            responseText: "SMS chat is stopped for this sender. Re-enable in Wingman settings/API.",
+            policy: control.policy
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+        const routing = {
+            ...parsed.routing
+        };
+        if ("string" == typeof body.accountId && body.accountId.trim()) routing.accountId = body.accountId.trim();
+        if ("string" == typeof body.threadId && body.threadId.trim()) routing.threadId = body.threadId.trim();
+        const selectedAgentId = ctx.router.selectAgent("string" == typeof body.agentId ? body.agentId.trim() : void 0, routing);
+        if (!selectedAgentId) return new Response("Unable to resolve agent", {
+            status: 400
+        });
+        const explicitSessionKey = "string" == typeof body.sessionKey ? body.sessionKey.trim() : "";
+        const sessionKey = explicitSessionKey || ctx.router.buildSessionKey(selectedAgentId, routing);
+        const request = {
+            agentId: selectedAgentId,
+            content: control.passThroughText,
+            routing,
+            sessionKey
+        };
+        if ("boolean" == typeof body.queueIfBusy) request.queueIfBusy = body.queueIfBusy;
+        return new Response(JSON.stringify({
+            kind: "agent",
+            target: parsed.normalizedTarget,
+            policy: control.policy,
+            request
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("/api/sms/policies" === url.pathname && "GET" === req.method) {
+        const targetRaw = url.searchParams.get("target");
+        if (targetRaw) {
+            const target = (0, policyStore_cjs_namespaceObject.normalizeSmsPolicyTarget)(targetRaw);
+            if (!target) return new Response("valid target query required", {
+                status: 400
+            });
+            const record = store.resolve(target);
+            return new Response(JSON.stringify(record, null, 2), {
+                headers: {
+                    "Content-Type": "application/json"
+                }
+            });
+        }
+        const policies = store.list();
+        return new Response(JSON.stringify({
+            policies
+        }, null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    const commandMatch = url.pathname.match(/^\/api\/sms\/policies\/([^/]+)\/command$/);
+    if (commandMatch) {
+        if ("POST" !== req.method) return new Response("Method Not Allowed", {
+            status: 405
+        });
+        const target = decodeTarget(commandMatch[1]);
+        if (!target) return new Response("valid target required", {
+            status: 400
+        });
+        let body;
+        try {
+            body = await req.json();
+        } catch  {
+            return new Response("Invalid JSON body", {
+                status: 400
+            });
+        }
+        const text = "string" == typeof body.text ? body.text : "";
+        const nowMs = "number" == typeof body.nowMs && Number.isFinite(body.nowMs) ? Math.trunc(body.nowMs) : Date.now();
+        const result = (0, control_cjs_namespaceObject.applySmsControlCommand)({
+            store,
+            target,
+            text,
+            nowMs
+        });
+        return new Response(JSON.stringify(toResponsePayload(result, nowMs), null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    const targetMatch = url.pathname.match(/^\/api\/sms\/policies\/([^/]+)$/);
+    if (!targetMatch) return null;
+    const target = decodeTarget(targetMatch[1]);
+    if (!target) return new Response("valid target required", {
+        status: 400
+    });
+    if ("GET" === req.method) return new Response(JSON.stringify(store.resolve(target), null, 2), {
+        headers: {
+            "Content-Type": "application/json"
+        }
+    });
+    if ("DELETE" === req.method) {
+        store.reset(target);
+        return new Response(JSON.stringify(store.resolve(target), null, 2), {
+            headers: {
+                "Content-Type": "application/json"
+            }
+        });
+    }
+    if ("PUT" !== req.method) return new Response("Method Not Allowed", {
+        status: 405
+    });
+    let body;
+    try {
+        body = await req.json();
+    } catch  {
+        return new Response("Invalid JSON body", {
+            status: 400
+        });
+    }
+    const patch = {};
+    const hasPauseForMs = Object.hasOwn(body ?? {}, "pauseForMs");
+    if (hasPauseForMs) {
+        const duration = parsePauseForMs(body.pauseForMs);
+        if (null === duration) return new Response("pauseForMs must be a positive duration", {
+            status: 400
+        });
+        const nowMs = Date.now();
+        patch.paused = true;
+        patch.pausedUntil = nowMs + duration;
+    }
+    if ("boolean" == typeof body.paused) patch.paused = body.paused;
+    if (Object.hasOwn(body ?? {}, "pausedUntil")) {
+        const value = body.pausedUntil;
+        if (null === value) {
+            patch.paused = false;
+            patch.pausedUntil = null;
+        } else {
+            if (!("number" == typeof value && Number.isFinite(value))) return new Response("pausedUntil must be a number or null", {
+                status: 400
+            });
+            patch.paused = true;
+            patch.pausedUntil = Math.trunc(value);
+        }
+    }
+    if ("boolean" == typeof body.stopEnabled) patch.stopEnabled = body.stopEnabled;
+    if ("off" === body.alertMode || "important-only" === body.alertMode || "all" === body.alertMode) patch.alertMode = body.alertMode;
+    if (Object.hasOwn(body ?? {}, "quietHours")) patch.quietHours = body.quietHours ?? null;
+    const updated = store.upsert(target, patch);
+    return new Response(JSON.stringify(updated, null, 2), {
+        headers: {
+            "Content-Type": "application/json"
+        }
+    });
+};
+exports.createSmsPolicyStateStore = __webpack_exports__.createSmsPolicyStateStore;
+exports.handleSmsApi = __webpack_exports__.handleSmsApi;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createSmsPolicyStateStore",
+    "handleSmsApi"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/gateway/http/sms.d.ts

@@ -0,0 +1,4 @@
+import { type SmsPolicyStore } from "../sms/policyStore.js";
+import type { GatewayHttpContext } from "./types.js";
+export declare const createSmsPolicyStateStore: (resolveConfigDirPath: () => string) => SmsPolicyStore;
+export declare const handleSmsApi: (ctx: GatewayHttpContext, store: SmsPolicyStore, req: Request, url: URL) => Promise<Response | null>;