@wabot-dev/framework 0.9.80 → 2.0.0-beta.0

package/dist/src/addon/chat-bot/in-memory/InMemoryChatMemory.js

@@ -20,9 +20,7 @@ class InMemoryChatMemory {
     filePath;
     onActivity;
     constructor(chatId, onActivity) {
-        this.filePath = chatId
-            ? path.resolve(process.cwd(), PERSIST_DIR, `${chatId}.json`)
-            : null;
+        this.filePath = chatId ? path.resolve(process.cwd(), PERSIST_DIR, `${chatId}.json`) : null;
         this.onActivity = onActivity ?? null;
         this.load();
     }

package/dist/src/addon/chat-bot/xai/XAIChatAdapter.js

@@ -0,0 +1,180 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../../feature/chat-bot/ChatAdapterRegistry.js';
+import '../../../feature/chat-bot/ChatBot.js';
+import '../../../feature/chat-bot/ChatOperator.js';
+import '../../../feature/chat-bot/UnionChatAdapter.js';
+import { extractChatMessageText } from '../../../feature/chat-bot/extractChatMessageText.js';
+import { isChatMessageEmpty } from '../../../feature/chat-bot/isChatMessageEmpty.js';
+import { isRetryableError } from '../../../feature/chat-bot/isRetryableError.js';
+import { chatAdapter } from '../../../feature/chat-bot/metadata/@chatAdapter.js';
+import { singleton } from '../../../core/injection/index.js';
+import 'uuid';
+import '../../../feature/chat-bot/metadata/ChatBotMetadataStore.js';
+import '../../../feature/chat-bot/metadata/ChatAdapterMetadataStore.js';
+import '../../../core/error/setupErrorHandlers.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { Env } from '../../../core/env/Env.js';
+import { OpenAI } from 'openai';
+
+const XAI_SUPPORTED_IMAGE_MIME_TYPES = [
+    'image/png',
+    'image/jpeg',
+    'image/webp',
+    'image/gif',
+];
+let XAIChatAdapter = class XAIChatAdapter {
+    env;
+    logger = new Logger('wabot:xai-chat-adapter');
+    client;
+    constructor(env) {
+        this.env = env;
+        this.client = new OpenAI({
+            apiKey: this.env.requireString('XAI_API_KEY'),
+            baseURL: 'https://api.x.ai/v1',
+        });
+    }
+    async nextItems(req) {
+        const messages = [];
+        if (req.systemPrompt) {
+            messages.push({ role: 'system', content: req.systemPrompt });
+        }
+        messages.push(...this.mapChatItems(req.prevItems));
+        const tools = req.tools.map((t) => this.mapTool(t));
+        const chatTools = tools.length > 0 ? tools : undefined;
+        let lastError;
+        for (const ref of req.models) {
+            try {
+                const result = await this.client.chat.completions.create({
+                    model: ref.model,
+                    messages,
+                    tools: chatTools,
+                });
+                return this.mapResponse(result, ref.model);
+            }
+            catch (err) {
+                if (!isRetryableError(err))
+                    throw err;
+                this.logger.warn(`xAI model '${ref.model}' failed with retryable error, trying next`, err instanceof Error ? { message: err.message } : { err });
+                lastError = err;
+            }
+        }
+        throw lastError ?? new Error('No xAI model could handle the request');
+    }
+    mapChatItems(items) {
+        const messages = [];
+        for (const item of items) {
+            switch (item.type) {
+                case 'humanMessage':
+                    messages.push(this.mapHumanMessage(item.humanMessage));
+                    break;
+                case 'botMessage':
+                    messages.push(this.mapBotMessage(item.botMessage));
+                    break;
+                case 'functionCall':
+                    messages.push(...this.mapFunctionCall(item.functionCall));
+                    break;
+            }
+        }
+        return messages;
+    }
+    mapHumanMessage(msg) {
+        if (isChatMessageEmpty(msg)) {
+            throw new Error('User message content is empty');
+        }
+        const content = [];
+        content.push({
+            type: 'text',
+            text: extractChatMessageText(msg, {
+                supportedImageMimeTypes: XAI_SUPPORTED_IMAGE_MIME_TYPES,
+            }),
+        });
+        if (msg.images) {
+            for (const image of msg.images) {
+                if (!XAI_SUPPORTED_IMAGE_MIME_TYPES.includes(image.mimeType))
+                    continue;
+                content.push(this.mapImage(image));
+            }
+        }
+        return { role: 'user', content };
+    }
+    mapImage(image) {
+        const url = image.publicUrl ?? image.base64Url;
+        return { type: 'image_url', image_url: { url } };
+    }
+    mapBotMessage(msg) {
+        if (!msg.text)
+            throw new Error('Assistant message content is empty');
+        return { role: 'assistant', content: msg.text };
+    }
+    mapFunctionCall(fc) {
+        return [
+            {
+                role: 'assistant',
+                content: '',
+                tool_calls: [
+                    {
+                        id: fc.id,
+                        type: 'function',
+                        function: { name: fc.name, arguments: fc.arguments || '{}' },
+                    },
+                ],
+            },
+            {
+                role: 'tool',
+                tool_call_id: fc.id,
+                content: String(fc.result ?? 'No result'),
+            },
+        ];
+    }
+    mapTool(tool) {
+        return {
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description,
+                parameters: {
+                    type: 'object',
+                    properties: tool.parameters.reduce((prev, param) => ({ ...prev, [param.name]: param.schema }), {}),
+                    required: tool.parameters.filter((p) => p.required).map((p) => p.name),
+                    additionalProperties: false,
+                },
+            },
+        };
+    }
+    mapResponse(result, modelName) {
+        const nextItems = [];
+        const choice = result.choices[0];
+        const text = choice?.message.content?.trim();
+        if (text) {
+            nextItems.push({ type: 'botMessage', botMessage: { text } });
+        }
+        if (choice?.message.tool_calls?.length) {
+            for (const call of choice.message.tool_calls) {
+                if (call.type !== 'function')
+                    continue;
+                nextItems.push({
+                    type: 'functionCall',
+                    functionCall: {
+                        id: call.id ?? '',
+                        name: call.function.name,
+                        arguments: call.function.arguments,
+                    },
+                });
+            }
+        }
+        const usage = {
+            inputTokens: result.usage?.prompt_tokens ?? 0,
+            outputTokens: result.usage?.completion_tokens ?? 0,
+            provider: 'xai',
+            model: result.model ?? modelName,
+        };
+        return { usage, nextItems };
+    }
+};
+XAIChatAdapter = __decorate([
+    chatAdapter({ provider: 'xai' }),
+    singleton(),
+    __metadata("design:paramtypes", [Env])
+], XAIChatAdapter);
+
+export { XAIChatAdapter };

package/dist/src/addon/chat-controller/cmd/cmdChannelSocketPath.js

@@ -3,11 +3,7 @@ import * as path from 'node:path';
 
 function cmdChannelSocketPath() {
     if (process.platform === 'win32') {
-        const cwdHash = crypto
-            .createHash('sha1')
-            .update(process.cwd())
-            .digest('hex')
-            .slice(0, 12);
+        const cwdHash = crypto.createHash('sha1').update(process.cwd()).digest('hex').slice(0, 12);
         return `\\\\.\\pipe\\wabot-cmd-channel-${cwdHash}`;
     }
     return path.resolve(process.cwd(), '.wabot/cmd-channel/socket');

package/dist/src/addon/chat-controller/hubspot/@hubspot.js

@@ -0,0 +1,28 @@
+import { container } from '../../../core/injection/index.js';
+import { resolveConfigReferences } from '../../../core/config/resolver.js';
+import { ControllerMetadataStore } from '../../../feature/chat-controller/metadata/ControllerMetadataStore.js';
+import '../../../feature/chat-controller/ChatResolver.js';
+import '../../../feature/chat-controller/runChatControllers.js';
+import { HubSpotChannel } from './HubSpotChannel.js';
+import { HubSpotChannelConfig } from './HubSpotChannelConfig.js';
+
+function hubspot(config) {
+    return function (target, propertyKey) {
+        const resolved = resolveConfigReferences(config);
+        const store = container.resolve(ControllerMetadataStore);
+        store.saveChannelMetadata({
+            channelConstructor: HubSpotChannel,
+            functionName: propertyKey.toString(),
+            controllerConstructor: target.constructor,
+            channelConfig: new HubSpotChannelConfig({
+                accessToken: resolved.accessToken,
+                webhookSecret: resolved.webhookSecret,
+                webhookPath: resolved.webhookPath,
+                appId: resolved.appId,
+                senderActorId: resolved.senderActorId,
+            }),
+        });
+    };
+}
+
+export { hubspot };

package/dist/src/addon/chat-controller/hubspot/HubSpotChannel.js

@@ -0,0 +1,81 @@
+import { __decorate, __metadata } from 'tslib';
+import { injectable } from '../../../core/injection/index.js';
+import { Env } from '../../../core/env/Env.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { hubspotChannelName } from './hubspotChannelName.js';
+import { HubSpotChannelConfig } from './HubSpotChannelConfig.js';
+import { HubSpotSender } from './HubSpotSender.js';
+import { HubSpotReceiver } from './HubSpotReceiver.js';
+import { markdownToChatHtml } from '../markdown/markdownToChatHtml.js';
+
+var HubSpotChannel_1;
+let HubSpotChannel = class HubSpotChannel {
+    static { HubSpotChannel_1 = this; }
+    static channelName = hubspotChannelName;
+    logger = new Logger(`wabot:hubspot-channel`);
+    sender;
+    receiver;
+    accessToken;
+    webhookSecret;
+    appId;
+    constructor(config, env) {
+        this.accessToken = config.accessToken ?? env.requireString('HUBSPOT_ACCESS_TOKEN');
+        this.webhookSecret = config.webhookSecret ?? env.requireString('HUBSPOT_WEBHOOK_SECRET');
+        this.appId = config.appId;
+        const resolvedConfig = new HubSpotChannelConfig({
+            accessToken: this.accessToken,
+            webhookSecret: this.webhookSecret,
+            webhookPath: config.webhookPath,
+            appId: this.appId,
+            senderActorId: config.senderActorId ?? process.env.HUBSPOT_SENDER_ACTOR_ID,
+        });
+        this.sender = new HubSpotSender(resolvedConfig);
+        this.receiver = new HubSpotReceiver(resolvedConfig);
+    }
+    listen(callback) {
+        this.receiver.listenMessage(async (payload) => {
+            await callback(this.toChannelMessage(payload, callback));
+        });
+    }
+    connect() {
+        this.receiver.connect();
+    }
+    disconnect() {
+        this.receiver.disconnect();
+    }
+    toChannelMessage(payload, callback) {
+        const chatConnection = {
+            id: payload.threadId,
+            chatType: 'PRIVATE',
+            channelName: HubSpotChannel_1.channelName,
+        };
+        return {
+            channel: hubspotChannelName,
+            chatConnection,
+            message: {
+                senderId: payload.senderId,
+                senderName: payload.senderName,
+                text: payload.text,
+                images: payload.files.length > 0 ? payload.files : undefined,
+                metadata: payload.metadata,
+            },
+            reply: async (replyMessage) => {
+                const text = replyMessage.text;
+                await this.sender.sendMessage({
+                    threadId: payload.threadId,
+                    text,
+                    richText: text ? markdownToChatHtml(text) : undefined,
+                    files: [...(replyMessage.images ?? []), ...(replyMessage.documents ?? [])],
+                    channelId: payload.channelId,
+                    channelAccountId: payload.channelAccountId,
+                });
+            },
+        };
+    }
+};
+HubSpotChannel = HubSpotChannel_1 = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [HubSpotChannelConfig, Env])
+], HubSpotChannel);
+
+export { HubSpotChannel };

package/dist/src/addon/chat-controller/hubspot/HubSpotChannelConfig.js

@@ -0,0 +1,20 @@
+import { hubspotChannelName } from './hubspotChannelName.js';
+
+class HubSpotChannelConfig {
+    channelName;
+    accessToken;
+    webhookSecret;
+    webhookPath;
+    appId;
+    senderActorId;
+    constructor(config) {
+        this.channelName = hubspotChannelName;
+        this.accessToken = config.accessToken;
+        this.webhookSecret = config.webhookSecret;
+        this.webhookPath = config.webhookPath ?? '/hubspot/webhook';
+        this.appId = config.appId;
+        this.senderActorId = config.senderActorId;
+    }
+}
+
+export { HubSpotChannelConfig };

package/dist/src/addon/chat-controller/hubspot/HubSpotReceiver.js

@@ -0,0 +1,42 @@
+import { __decorate, __metadata } from 'tslib';
+import '../../../core/injection/index.js';
+import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import { restController } from '../../../feature/rest-controller/metadata/@restController.js';
+import { runRestControllers } from '../../../feature/rest-controller/runRestControllers.js';
+import { HubSpotWebhookController } from './HubSpotWebhookController.js';
+
+class HubSpotReceiver {
+    config;
+    listener = null;
+    constructor(config) {
+        this.config = config;
+    }
+    listenMessage(listener) {
+        this.listener = listener;
+    }
+    connect() {
+        const listener = this.listener;
+        if (!listener) {
+            throw new Error('HubSpotReceiver.connect() called before listenMessage()');
+        }
+        const webhookPath = this.config.webhookPath;
+        const webhookSecret = this.config.webhookSecret;
+        const accessToken = this.config.accessToken;
+        const channelName = this.config.channelName;
+        let UniqueController = class UniqueController extends HubSpotWebhookController {
+            constructor() {
+                super({ webhookSecret, accessToken, listener: listener, channelName });
+            }
+        };
+        UniqueController = __decorate([
+            restController(webhookPath),
+            __metadata("design:paramtypes", [])
+        ], UniqueController);
+        runRestControllers([UniqueController]);
+    }
+    disconnect() {
+        // No-op: the webhook is registered with Express and lives until the app shuts down.
+    }
+}
+
+export { HubSpotReceiver };

package/dist/src/addon/chat-controller/hubspot/HubSpotSender.js

@@ -0,0 +1,118 @@
+import { __decorate, __metadata } from 'tslib';
+import { Client } from '@hubspot/api-client';
+import { injectable } from '../../../core/injection/index.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import { HubSpotChannelConfig } from './HubSpotChannelConfig.js';
+
+let HubSpotSender = class HubSpotSender {
+    client;
+    accessToken;
+    baseUrl;
+    logger = new Logger('wabot:hubspot-sender');
+    defaultSenderActorId;
+    constructor(config, client) {
+        this.client = client ?? new Client({ accessToken: config.accessToken });
+        this.accessToken = config.accessToken;
+        this.baseUrl = 'https://api.hubapi.com';
+        this.defaultSenderActorId = config.senderActorId;
+    }
+    async sendMessage(req) {
+        const fileIds = [];
+        if (req.files && req.files.length > 0) {
+            for (const file of req.files) {
+                const uploaded = await this.uploadFile(file);
+                fileIds.push(uploaded.id);
+            }
+        }
+        const body = {
+            type: 'MESSAGE',
+        };
+        if (req.text)
+            body.text = req.text;
+        if (req.richText)
+            body.richText = req.richText;
+        if (fileIds.length > 0) {
+            body.attachments = fileIds.map((fileId) => ({ fileId }));
+        }
+        if (req.senderActorId)
+            body.senderActorId = req.senderActorId;
+        else if (this.defaultSenderActorId)
+            body.senderActorId = this.defaultSenderActorId;
+        if (req.channelId)
+            body.channelId = req.channelId;
+        if (req.channelAccountId)
+            body.channelAccountId = req.channelAccountId;
+        if (!body.text && !body.richText && (!body.attachments || body.attachments.length === 0)) {
+            throw new Error('HubSpot sendMessage requires at least text, richText or files');
+        }
+        const path = `/conversations/v3/conversations/threads/${encodeURIComponent(req.threadId)}/messages`;
+        const response = await this.client.apiRequest({
+            method: 'POST',
+            path,
+            body: JSON.stringify(body),
+            headers: { 'Content-Type': 'application/json' },
+            defaultJson: false,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text();
+            this.logger.error(`HubSpot sendMessage failed for thread '${req.threadId}': ${response.status} ${errorBody}`);
+            throw new Error(`HubSpot sendMessage failed: ${response.status} ${errorBody}`);
+        }
+        const data = (await response.json());
+        if (!data.id) {
+            throw new Error('HubSpot sendMessage response did not include an id');
+        }
+        this.logger.trace(`HubSpot message sent to thread '${req.threadId}' as '${data.id}'`);
+        return { messageId: data.id };
+    }
+    async uploadFile(file) {
+        const httpFile = await toHttpFile(file);
+        const form = new FormData();
+        const fileBytes = new Uint8Array(httpFile.data);
+        form.append('file', new Blob([fileBytes]), httpFile.name);
+        form.append('options', JSON.stringify({ access: 'PUBLIC_INDEXABLE', overwrite: false }));
+        form.append('folderPath', '/');
+        const response = await fetch(`${this.baseUrl}/files/v3/files`, {
+            method: 'POST',
+            headers: { Authorization: `Bearer ${this.accessToken}` },
+            body: form,
+        });
+        if (!response.ok) {
+            const errorBody = await response.text();
+            this.logger.error(`HubSpot file upload failed for '${httpFile.name}': ${response.status} ${errorBody}`);
+            throw new Error(`HubSpot file upload failed: ${response.status} ${errorBody}`);
+        }
+        const data = (await response.json());
+        if (!data.id) {
+            throw new Error('HubSpot file upload response did not include an id');
+        }
+        return { id: String(data.id) };
+    }
+};
+HubSpotSender = __decorate([
+    injectable(),
+    __metadata("design:paramtypes", [HubSpotChannelConfig, Client])
+], HubSpotSender);
+async function toHttpFile(file) {
+    const name = file.name ?? file.id;
+    if (file.base64Url) {
+        const data = decodeBase64Url(file.base64Url);
+        return { data, name };
+    }
+    if (file.publicUrl) {
+        const res = await fetch(file.publicUrl);
+        if (!res.ok) {
+            throw new Error(`Failed to download file from publicUrl: ${res.status}`);
+        }
+        const arrayBuffer = await res.arrayBuffer();
+        return { data: Buffer.from(arrayBuffer), name };
+    }
+    throw new Error('IChatMessageFile has neither base64Url nor publicUrl');
+}
+function decodeBase64Url(dataUri) {
+    const commaIdx = dataUri.indexOf(',');
+    const payload = commaIdx >= 0 ? dataUri.slice(commaIdx + 1) : dataUri;
+    return Buffer.from(payload, 'base64');
+}
+
+export { HubSpotSender };

package/dist/src/addon/chat-controller/hubspot/HubSpotWebhookController.js

@@ -0,0 +1,122 @@
+import { __decorate, __metadata } from 'tslib';
+import { IncomingMessage } from 'node:http';
+import { CustomError } from '../../../core/error/CustomError.js';
+import '../../../core/error/setupErrorHandlers.js';
+import { Logger } from '../../../core/logger/Logger.js';
+import '../../../core/injection/index.js';
+import '../../../feature/rest-controller/metadata/RestControllerMetadataStore.js';
+import { onPost } from '../../../feature/rest-controller/metadata/@onPost.js';
+import { downloadHubSpotAttachments } from './downloadHubSpotAttachments.js';
+import { verifyHubSpotSignatureV3 } from './verifyHubSpotSignatureV3.js';
+
+const SIGNATURE_HEADER = 'x-hubspot-signature-v3';
+const TIMESTAMP_HEADER = 'x-hubspot-request-timestamp';
+class HubSpotWebhookController {
+    logger;
+    webhookSecret;
+    accessToken;
+    listener;
+    channelName;
+    constructor(deps) {
+        this.logger = new Logger(`wabot:hubspot-webhook:${deps.channelName}`);
+        this.webhookSecret = deps.webhookSecret;
+        this.accessToken = deps.accessToken;
+        this.listener = deps.listener;
+        this.channelName = deps.channelName;
+    }
+    async handleWebhook(req) {
+        const rawBody = await readRawBody(req);
+        const signature = headerValue(req, SIGNATURE_HEADER);
+        const timestamp = headerValue(req, TIMESTAMP_HEADER);
+        const requestUri = req.url ?? '/';
+        if (!signature || !timestamp) {
+            this.logger.warn('missing signature or timestamp header');
+            throw new CustomError({ httpCode: 401, message: 'missing signature headers' });
+        }
+        const ok = verifyHubSpotSignatureV3({
+            secret: this.webhookSecret,
+            method: req.method ?? 'POST',
+            url: requestUri,
+            rawBody,
+            timestampHeader: timestamp,
+            signatureHeader: signature,
+        });
+        if (!ok) {
+            this.logger.warn(`invalid signature for ${requestUri}`);
+            throw new CustomError({ httpCode: 401, message: 'invalid signature' });
+        }
+        let batch;
+        try {
+            batch = JSON.parse(rawBody);
+        }
+        catch (err) {
+            this.logger.warn(`failed to parse webhook body: ${err.message}`);
+            throw new CustomError({ httpCode: 400, message: 'invalid JSON body' });
+        }
+        if (!Array.isArray(batch)) {
+            throw new CustomError({ httpCode: 400, message: 'expected event batch array' });
+        }
+        for (const event of batch) {
+            await this.dispatch(event);
+        }
+        return null;
+    }
+    async dispatch(event) {
+        if (event.subscriptionType !== 'conversation.creation' &&
+            event.subscriptionType !== 'conversation.newMessage') {
+            this.logger.warn(`unhandled subscription type: ${event.subscriptionType ?? 'unknown'}`);
+            return;
+        }
+        const evt = event;
+        if (!evt.message || evt.message.direction !== 'INCOMING') {
+            return;
+        }
+        const msg = evt.message;
+        const files = await downloadHubSpotAttachments(msg.attachments, {
+            accessToken: this.accessToken,
+            logger: this.logger,
+        });
+        const payload = {
+            threadId: msg.threadId ?? evt.objectId ?? '',
+            messageId: msg.id,
+            senderId: msg.from?.actorId ?? 'unknown',
+            senderName: msg.from?.name,
+            channel: msg.channel,
+            channelId: msg.channelId,
+            channelAccountId: msg.channelAccountId,
+            text: msg.text,
+            files,
+            metadata: {
+                subscriptionType: event.subscriptionType,
+                portalId: String(evt.portalId ?? ''),
+                appId: evt.appId != null ? String(evt.appId) : '',
+                channelName: this.channelName,
+            },
+        };
+        await this.listener(payload);
+    }
+}
+__decorate([
+    onPost({ disableJsonParser: true, disableUrlEncodedParser: true }),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [IncomingMessage]),
+    __metadata("design:returntype", Promise)
+], HubSpotWebhookController.prototype, "handleWebhook", null);
+function headerValue(req, name) {
+    const value = req.headers[name];
+    if (Array.isArray(value))
+        return value[0];
+    return value;
+}
+function readRawBody(req) {
+    return new Promise((resolve, reject) => {
+        let data = '';
+        req.on('data', (chunk) => {
+            data += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+        });
+        req.on('end', () => resolve(data));
+        req.on('error', (err) => reject(err));
+    });
+}
+
+export { HubSpotWebhookController };

package/dist/src/addon/chat-controller/hubspot/downloadHubSpotAttachments.js

@@ -0,0 +1,45 @@
+// Inline the HubSpot attachment bytes as `base64Url` data-URIs so downstream
+// chat-bot consumers can forward them to LLM providers without HubSpot tokens
+// or signed URLs. Mirrors the Telegram strategy in TelegramChannel.downloadChatFile.
+async function downloadHubSpotAttachments(attachments, options) {
+    if (!attachments || attachments.length === 0)
+        return [];
+    const files = [];
+    for (const attachment of attachments) {
+        const file = await downloadOne(attachment, options);
+        if (file)
+            files.push(file);
+    }
+    return files;
+}
+async function downloadOne(attachment, options) {
+    const id = attachment.fileId ?? attachment.id;
+    const name = attachment.name;
+    const mimeType = attachment.mimeType ?? 'application/octet-stream';
+    if (!attachment.url) {
+        options.logger?.warn(`HubSpot attachment '${id}' has no url; skipping`);
+        return null;
+    }
+    try {
+        const response = await fetch(attachment.url, {
+            headers: { Authorization: `Bearer ${options.accessToken}` },
+        });
+        if (!response.ok) {
+            throw new Error(`${response.status} ${response.statusText}`);
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const base64 = Buffer.from(arrayBuffer).toString('base64');
+        return {
+            id,
+            name,
+            mimeType,
+            base64Url: `data:${mimeType};base64,${base64}`,
+        };
+    }
+    catch (err) {
+        options.logger?.warn(`failed to download HubSpot attachment '${id}': ${err.message}`);
+        return null;
+    }
+}
+
+export { downloadHubSpotAttachments };

package/dist/src/addon/chat-controller/hubspot/hubspotChannelName.js

@@ -0,0 +1,3 @@
+const hubspotChannelName = 'HubSpotChannel';
+
+export { hubspotChannelName };