@wingman-ai/gateway 0.1.0

package/dist/cli/ui/components/ToolResultDisplay.cjs

@@ -0,0 +1,86 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __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__, {
+    ToolResultDisplay: ()=>ToolResultDisplay
+});
+const external_react_namespaceObject = require("react");
+var external_react_default = /*#__PURE__*/ __webpack_require__.n(external_react_namespaceObject);
+const external_ink_namespaceObject = require("ink");
+const MAX_PREVIEW_LENGTH = 200;
+const ToolResultDisplay = ({ result, executionTime })=>{
+    const hasError = !!result.error;
+    const outputLength = result.output.length;
+    const isLong = outputLength > MAX_PREVIEW_LENGTH;
+    const preview = isLong ? result.output.substring(0, MAX_PREVIEW_LENGTH) + "..." : result.output;
+    return /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        flexDirection: "column",
+        marginY: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        borderStyle: "single",
+        borderColor: hasError ? "red" : "gray",
+        paddingX: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        flexDirection: "column",
+        width: "100%"
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, null, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        bold: true,
+        color: hasError ? "red" : "green"
+    }, hasError ? "✗ Error" : "✓ Result"), void 0 !== executionTime && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        dimColor: true
+    }, " (", executionTime.toFixed(2), "s)")), hasError && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        color: "red"
+    }, result.error)), !hasError && result.output && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        flexDirection: "column",
+        marginTop: 1
+    }, isLong && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        dimColor: true
+    }, "(", outputLength.toLocaleString(), " characters)"), /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        marginTop: isLong ? 1 : 0
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, null, preview)), result.truncated && /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ external_react_default().createElement(external_ink_namespaceObject.Text, {
+        dimColor: true,
+        italic: true
+    }, "[Output truncated - full result available in session]"))))));
+};
+exports.ToolResultDisplay = __webpack_exports__.ToolResultDisplay;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ToolResultDisplay"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/ui/components/ToolResultDisplay.d.ts

@@ -0,0 +1,8 @@
+import React from "react";
+import type { ToolResultBlock } from "../../types.js";
+interface ToolResultDisplayProps {
+    result: ToolResultBlock;
+    executionTime?: number;
+}
+export declare const ToolResultDisplay: React.FC<ToolResultDisplayProps>;
+export {};

package/dist/cli/ui/components/ToolResultDisplay.js

@@ -0,0 +1,42 @@
+import react from "react";
+import { Box, Text } from "ink";
+const MAX_PREVIEW_LENGTH = 200;
+const ToolResultDisplay = ({ result, executionTime })=>{
+    const hasError = !!result.error;
+    const outputLength = result.output.length;
+    const isLong = outputLength > MAX_PREVIEW_LENGTH;
+    const preview = isLong ? result.output.substring(0, MAX_PREVIEW_LENGTH) + "..." : result.output;
+    return /*#__PURE__*/ react.createElement(Box, {
+        flexDirection: "column",
+        marginY: 1
+    }, /*#__PURE__*/ react.createElement(Box, {
+        borderStyle: "single",
+        borderColor: hasError ? "red" : "gray",
+        paddingX: 1
+    }, /*#__PURE__*/ react.createElement(Box, {
+        flexDirection: "column",
+        width: "100%"
+    }, /*#__PURE__*/ react.createElement(Box, null, /*#__PURE__*/ react.createElement(Text, {
+        bold: true,
+        color: hasError ? "red" : "green"
+    }, hasError ? "✗ Error" : "✓ Result"), void 0 !== executionTime && /*#__PURE__*/ react.createElement(Text, {
+        dimColor: true
+    }, " (", executionTime.toFixed(2), "s)")), hasError && /*#__PURE__*/ react.createElement(Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ react.createElement(Text, {
+        color: "red"
+    }, result.error)), !hasError && result.output && /*#__PURE__*/ react.createElement(Box, {
+        flexDirection: "column",
+        marginTop: 1
+    }, isLong && /*#__PURE__*/ react.createElement(Text, {
+        dimColor: true
+    }, "(", outputLength.toLocaleString(), " characters)"), /*#__PURE__*/ react.createElement(Box, {
+        marginTop: isLong ? 1 : 0
+    }, /*#__PURE__*/ react.createElement(Text, null, preview)), result.truncated && /*#__PURE__*/ react.createElement(Box, {
+        marginTop: 1
+    }, /*#__PURE__*/ react.createElement(Text, {
+        dimColor: true,
+        italic: true
+    }, "[Output truncated - full result available in session]"))))));
+};
+export { ToolResultDisplay };

package/dist/cli/ui/toolDisplayHelpers.cjs

@@ -0,0 +1,112 @@
+"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__, {
+    extractSubagentName: ()=>extractSubagentName,
+    extractTaskSummary: ()=>extractTaskSummary,
+    isTaskTool: ()=>isTaskTool
+});
+const TASK_TOOL_NAME = "task";
+function isTaskTool(name) {
+    return name.trim().toLowerCase() === TASK_TOOL_NAME;
+}
+function extractSubagentName(args) {
+    if (!args || "object" != typeof args) return null;
+    const directKeys = [
+        "subagent",
+        "subAgent",
+        "agent",
+        "agentName",
+        "name",
+        "id",
+        "role"
+    ];
+    const direct = pickStringFromKeys(args, directKeys);
+    if (direct) return direct;
+    const nestedKeys = [
+        "agent",
+        "subagent",
+        "delegate",
+        "worker",
+        "assistant"
+    ];
+    for (const key of nestedKeys){
+        const value = args[key];
+        if (!value || "object" != typeof value) continue;
+        const nested = pickStringFromKeys(value, [
+            "name",
+            "id",
+            "role",
+            "agent"
+        ]);
+        if (nested) return nested;
+    }
+    return null;
+}
+function extractTaskSummary(args) {
+    if (!args || "object" != typeof args) return null;
+    const summaryKeys = [
+        "task",
+        "goal",
+        "objective",
+        "instruction",
+        "prompt",
+        "message",
+        "query",
+        "description"
+    ];
+    const summary = pickStringFromKeys(args, summaryKeys);
+    if (summary) return summary;
+    if ("string" == typeof args.input) return args.input;
+    return null;
+}
+function pickStringFromKeys(source, keys) {
+    for (const key of keys){
+        const value = source[key];
+        const picked = normalizeString(value);
+        if (picked) return picked;
+        if (value && "object" == typeof value) {
+            const nested = normalizeString(value.name) || normalizeString(value.id);
+            if (nested) return nested;
+        }
+    }
+    return null;
+}
+function normalizeString(value) {
+    if ("string" != typeof value) return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+exports.extractSubagentName = __webpack_exports__.extractSubagentName;
+exports.extractTaskSummary = __webpack_exports__.extractTaskSummary;
+exports.isTaskTool = __webpack_exports__.isTaskTool;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "extractSubagentName",
+    "extractTaskSummary",
+    "isTaskTool"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cli/ui/toolDisplayHelpers.d.ts

@@ -0,0 +1,3 @@
+export declare function isTaskTool(name: string): boolean;
+export declare function extractSubagentName(args: Record<string, any>): string | null;
+export declare function extractTaskSummary(args: Record<string, any>): string | null;

package/dist/cli/ui/toolDisplayHelpers.js

@@ -0,0 +1,72 @@
+const TASK_TOOL_NAME = "task";
+function isTaskTool(name) {
+    return name.trim().toLowerCase() === TASK_TOOL_NAME;
+}
+function extractSubagentName(args) {
+    if (!args || "object" != typeof args) return null;
+    const directKeys = [
+        "subagent",
+        "subAgent",
+        "agent",
+        "agentName",
+        "name",
+        "id",
+        "role"
+    ];
+    const direct = pickStringFromKeys(args, directKeys);
+    if (direct) return direct;
+    const nestedKeys = [
+        "agent",
+        "subagent",
+        "delegate",
+        "worker",
+        "assistant"
+    ];
+    for (const key of nestedKeys){
+        const value = args[key];
+        if (!value || "object" != typeof value) continue;
+        const nested = pickStringFromKeys(value, [
+            "name",
+            "id",
+            "role",
+            "agent"
+        ]);
+        if (nested) return nested;
+    }
+    return null;
+}
+function extractTaskSummary(args) {
+    if (!args || "object" != typeof args) return null;
+    const summaryKeys = [
+        "task",
+        "goal",
+        "objective",
+        "instruction",
+        "prompt",
+        "message",
+        "query",
+        "description"
+    ];
+    const summary = pickStringFromKeys(args, summaryKeys);
+    if (summary) return summary;
+    if ("string" == typeof args.input) return args.input;
+    return null;
+}
+function pickStringFromKeys(source, keys) {
+    for (const key of keys){
+        const value = source[key];
+        const picked = normalizeString(value);
+        if (picked) return picked;
+        if (value && "object" == typeof value) {
+            const nested = normalizeString(value.name) || normalizeString(value.id);
+            if (nested) return nested;
+        }
+    }
+    return null;
+}
+function normalizeString(value) {
+    if ("string" != typeof value) return null;
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+export { extractSubagentName, extractTaskSummary, isTaskTool };

package/dist/gateway/adapters/discord.cjs

@@ -0,0 +1,298 @@
+"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__, {
+    DiscordGatewayAdapter: ()=>DiscordGatewayAdapter,
+    parseAgentIdFromSessionKey: ()=>parseAgentIdFromSessionKey,
+    extractSessionOverride: ()=>extractSessionOverride,
+    splitDiscordMessage: ()=>splitDiscordMessage,
+    DEFAULT_DISCORD_RESPONSE_CHUNK: ()=>DEFAULT_DISCORD_RESPONSE_CHUNK,
+    resolveDiscordChannelSessionKey: ()=>resolveDiscordChannelSessionKey,
+    stripDiscordBotMention: ()=>stripDiscordBotMention
+});
+const external_discord_js_namespaceObject = require("discord.js");
+const external_logger_cjs_namespaceObject = require("../../logger.cjs");
+const external_rpcClient_cjs_namespaceObject = require("../rpcClient.cjs");
+const streamParser_cjs_namespaceObject = require("../../cli/core/streamParser.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_DISCORD_RESPONSE_CHUNK = 1900;
+function splitDiscordMessage(text, maxLength = DEFAULT_DISCORD_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 stripDiscordBotMention(content, botId) {
+    if (!content) return content;
+    const mention = new RegExp(`<@!?${botId}>`, "g");
+    return content.replace(mention, "").trim();
+}
+function extractSessionOverride(content, command) {
+    const trimmed = content.trim();
+    if (!command || !trimmed.toLowerCase().startsWith(command.toLowerCase())) return {
+        content,
+        matched: false
+    };
+    const withoutCommand = trimmed.slice(command.length).trim();
+    if (!withoutCommand) return {
+        content: "",
+        matched: true
+    };
+    const [sessionKey, ...rest] = withoutCommand.split(/\s+/);
+    return {
+        sessionKey,
+        content: rest.join(" "),
+        matched: true
+    };
+}
+function resolveDiscordChannelSessionKey(channelId, channelSessions, parentChannelId) {
+    if (!channelSessions) return;
+    const direct = channelSessions[channelId];
+    if (direct) return direct;
+    if (parentChannelId) return channelSessions[parentChannelId];
+}
+function parseAgentIdFromSessionKey(sessionKey) {
+    if (!sessionKey) return;
+    const match = sessionKey.match(/^agent:([^:]+):/);
+    return match?.[1];
+}
+function buildRoutingInfo(message, botUserId) {
+    const routing = {
+        channel: "discord",
+        accountId: botUserId
+    };
+    if (message.guildId) routing.guildId = message.guildId;
+    const channel = message.channel;
+    if (channel.isDMBased()) {
+        if (channel.type === external_discord_js_namespaceObject.ChannelType.DM) routing.peer = {
+            kind: "dm",
+            id: message.author.id
+        };
+        else routing.peer = {
+            kind: "group",
+            id: channel.id
+        };
+        return routing;
+    }
+    if (channel.isThread()) {
+        routing.threadId = channel.id;
+        routing.peer = {
+            kind: "channel",
+            id: channel.parentId || channel.id
+        };
+        return routing;
+    }
+    routing.peer = {
+        kind: "channel",
+        id: channel.id
+    };
+    return routing;
+}
+class DiscordGatewayAdapter {
+    async start() {
+        if (this.started) return;
+        if (!this.config.enabled) return;
+        if (!this.config.token) return void this.logger.warn("Discord adapter enabled but no token configured.");
+        this.gatewayClient = new external_rpcClient_cjs_namespaceObject.GatewayRpcClient(this.gateway.url, {
+            token: this.gateway.token,
+            password: this.gateway.password,
+            clientType: "discord"
+        });
+        await this.gatewayClient.connect();
+        this.client = new external_discord_js_namespaceObject.Client({
+            intents: [
+                external_discord_js_namespaceObject.GatewayIntentBits.Guilds,
+                external_discord_js_namespaceObject.GatewayIntentBits.GuildMessages,
+                external_discord_js_namespaceObject.GatewayIntentBits.DirectMessages,
+                external_discord_js_namespaceObject.GatewayIntentBits.MessageContent
+            ],
+            partials: [
+                external_discord_js_namespaceObject.Partials.Channel
+            ]
+        });
+        this.client.on("clientReady", ()=>{
+            this.logger.info("Discord adapter connected.");
+        });
+        this.client.on("error", (error)=>{
+            this.logger.error("Discord adapter error", error);
+        });
+        this.client.on("messageCreate", (message)=>{
+            this.handleMessage(message);
+        });
+        await this.client.login(this.config.token);
+        this.started = true;
+    }
+    async stop() {
+        if (!this.started) return;
+        this.started = false;
+        if (this.client) {
+            await this.client.destroy();
+            this.client = null;
+        }
+        if (this.gatewayClient) {
+            this.gatewayClient.disconnect();
+            this.gatewayClient = null;
+        }
+    }
+    async handleMessage(message) {
+        if (!this.client || !this.gatewayClient) return;
+        if (!message.content && 0 === message.attachments.size) return;
+        if (message.author.bot) {
+            if (!this.config.allowBots) return;
+            if (message.author.id === this.client.user?.id) return;
+        }
+        const botUserId = this.client.user?.id;
+        if (!botUserId) return;
+        if (!message.channel.isTextBased()) return;
+        const channel = message.channel;
+        if (!("send" in channel)) return;
+        const sendChannel = channel;
+        if (this.config.allowedGuilds.length > 0 && message.guildId) {
+            if (!this.config.allowedGuilds.includes(message.guildId)) return;
+        }
+        if (this.config.allowedChannels.length > 0) {
+            if (!this.config.allowedChannels.includes(message.channelId)) return;
+        }
+        const isDm = message.channel.isDMBased();
+        const mentioned = message.mentions.has(botUserId);
+        if (this.config.mentionOnly && !isDm && !mentioned) return;
+        const cleaned = stripDiscordBotMention(message.content || "", botUserId);
+        const attachments = Array.from(message.attachments.values()).map((attachment)=>attachment.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 sendChannel.send(`Provide a session key after \`${this.config.sessionCommand}\`.`);
+        }
+        if (!matched) {
+            const parentChannelId = message.channel.isThread() ? message.channel.parentId ?? void 0 : void 0;
+            resolvedSessionKey = resolveDiscordChannelSessionKey(message.channelId, this.config.channelSessions, parentChannelId);
+            usedChannelMapping = Boolean(resolvedSessionKey);
+        }
+        const inferredAgentId = parseAgentIdFromSessionKey(resolvedSessionKey);
+        if (usedChannelMapping && !inferredAgentId) this.logger.warn(`Discord channel session mapping for channel ${message.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(message, botUserId),
+            sessionKey: resolvedSessionKey
+        };
+        try {
+            if (sendChannel.sendTyping) await sendChannel.sendTyping();
+            let fallbackText = "";
+            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 ("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");
+            const responseText = `${fallbackText}${fallbackText && orderedText ? "\n\n" : ""}${orderedText}`.trim();
+            if (!responseText) return;
+            const chunks = splitDiscordMessage(responseText, this.config.responseChunkSize);
+            for (const chunk of chunks)await sendChannel.send(chunk);
+        } catch (error) {
+            this.logger.error("Discord adapter failed to handle message", error);
+            try {
+                await sendChannel.send("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, "client", 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.client = null;
+        this.gatewayClient = null;
+        this.started = false;
+        this.logger = logger || (0, external_logger_cjs_namespaceObject.createLogger)();
+    }
+}
+exports.DEFAULT_DISCORD_RESPONSE_CHUNK = __webpack_exports__.DEFAULT_DISCORD_RESPONSE_CHUNK;
+exports.DiscordGatewayAdapter = __webpack_exports__.DiscordGatewayAdapter;
+exports.extractSessionOverride = __webpack_exports__.extractSessionOverride;
+exports.parseAgentIdFromSessionKey = __webpack_exports__.parseAgentIdFromSessionKey;
+exports.resolveDiscordChannelSessionKey = __webpack_exports__.resolveDiscordChannelSessionKey;
+exports.splitDiscordMessage = __webpack_exports__.splitDiscordMessage;
+exports.stripDiscordBotMention = __webpack_exports__.stripDiscordBotMention;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "DEFAULT_DISCORD_RESPONSE_CHUNK",
+    "DiscordGatewayAdapter",
+    "extractSessionOverride",
+    "parseAgentIdFromSessionKey",
+    "resolveDiscordChannelSessionKey",
+    "splitDiscordMessage",
+    "stripDiscordBotMention"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

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

@@ -0,0 +1,42 @@
+import { type Logger } from "@/logger.js";
+export interface DiscordAdapterConfig {
+    enabled: boolean;
+    token?: string;
+    mentionOnly: boolean;
+    allowBots: boolean;
+    allowedGuilds: string[];
+    allowedChannels: string[];
+    channelSessions?: Record<string, string>;
+    sessionCommand: string;
+    gatewayUrl?: string;
+    gatewayToken?: string;
+    gatewayPassword?: string;
+    responseChunkSize: number;
+}
+export interface DiscordAdapterGatewayConfig {
+    url: string;
+    token?: string;
+    password?: string;
+}
+export declare const DEFAULT_DISCORD_RESPONSE_CHUNK = 1900;
+export declare function splitDiscordMessage(text: string, maxLength?: number): string[];
+export declare function stripDiscordBotMention(content: string, botId: string): string;
+export declare function extractSessionOverride(content: string, command: string): {
+    sessionKey?: string;
+    content: string;
+    matched: boolean;
+};
+export declare function resolveDiscordChannelSessionKey(channelId: string, channelSessions?: Record<string, string>, parentChannelId?: string): string | undefined;
+export declare function parseAgentIdFromSessionKey(sessionKey?: string): string | undefined;
+export declare class DiscordGatewayAdapter {
+    private config;
+    private gateway;
+    private client;
+    private gatewayClient;
+    private logger;
+    private started;
+    constructor(config: DiscordAdapterConfig, gateway: DiscordAdapterGatewayConfig, logger?: Logger);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleMessage;
+}