@pellux/goodvibes-sdk 0.18.13 → 0.18.15

package/dist/_internal/platform/channels/delivery/strategies-bridge.js

@@ -0,0 +1,165 @@
+import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import { ConfigManager } from '../../config/manager.js';
+import { ServiceRegistry } from '../../config/service-registry.js';
+import { appendAttachmentSummary, extractResponseId, firstNonEmpty, normalizeBaseUrl, postBridgePayload, requireOkResponse, resolveAttachments, resolveChannelDeliverySurfaceKind, success, trimForSurface, } from './shared.js';
+export function createSignalDeliveryStrategy(configManager, serviceRegistry, artifactStore) {
+    return {
+        id: 'channel-delivery:signal',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'signal';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager);
+            const bridgeUrl = firstNonEmpty(request.target.address?.startsWith('https://') ? request.target.address : undefined, String(configManager.get('surfaces.signal.bridgeUrl') ?? ''), serviceRegistry.get('signal')?.baseUrl, process.env.SIGNAL_BRIDGE_URL);
+            const recipient = firstNonEmpty(request.target.address?.startsWith('https://') ? undefined : request.target.address, request.binding?.channelId, request.binding?.externalId, String(configManager.get('surfaces.signal.defaultRecipient') ?? ''));
+            if (!bridgeUrl)
+                throw new Error('Missing Signal bridge URL');
+            if (!recipient)
+                throw new Error('Missing Signal recipient');
+            const token = firstNonEmpty(await serviceRegistry.resolveSecret('signal', 'primary'), String(configManager.get('surfaces.signal.token') ?? ''), process.env.SIGNAL_BRIDGE_TOKEN);
+            const responseId = await postBridgePayload(bridgeUrl, {
+                surface: 'signal',
+                account: firstNonEmpty(String(configManager.get('surfaces.signal.account') ?? '')),
+                recipient,
+                text: trimForSurface(appendAttachmentSummary(request.body, attachments), 8_000),
+                title: request.title,
+                jobId: request.jobId,
+                runId: request.runId,
+                routeId: request.binding?.id,
+                threadId: request.binding?.threadId,
+                attachments,
+            }, {
+                label: 'Signal bridge delivery failed',
+                token,
+            });
+            return success(responseId ?? recipient);
+        },
+    };
+}
+export function createWhatsAppDeliveryStrategy(configManager, serviceRegistry, artifactStore) {
+    return {
+        id: 'channel-delivery:whatsapp',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'whatsapp';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager);
+            const provider = firstNonEmpty(String(configManager.get('surfaces.whatsapp.provider') ?? ''), 'meta-cloud') ?? 'meta-cloud';
+            const recipient = firstNonEmpty(request.target.address?.startsWith('https://') ? undefined : request.target.address, request.binding?.channelId, request.binding?.externalId, String(configManager.get('surfaces.whatsapp.defaultRecipient') ?? ''));
+            if (!recipient)
+                throw new Error('Missing WhatsApp recipient');
+            if (provider === 'bridge') {
+                const bridgeUrl = firstNonEmpty(request.target.address?.startsWith('https://') ? request.target.address : undefined, serviceRegistry.get('whatsapp')?.baseUrl, process.env.WHATSAPP_BRIDGE_URL);
+                if (!bridgeUrl)
+                    throw new Error('Missing WhatsApp bridge URL');
+                const token = firstNonEmpty(await serviceRegistry.resolveSecret('whatsapp', 'primary'), String(configManager.get('surfaces.whatsapp.accessToken') ?? ''), process.env.WHATSAPP_ACCESS_TOKEN);
+                const responseId = await postBridgePayload(bridgeUrl, {
+                    surface: 'whatsapp',
+                    provider,
+                    recipient,
+                    text: trimForSurface(appendAttachmentSummary(request.body, attachments), 4_096),
+                    title: request.title,
+                    jobId: request.jobId,
+                    runId: request.runId,
+                    routeId: request.binding?.id,
+                    attachments,
+                }, {
+                    label: 'WhatsApp bridge delivery failed',
+                    token,
+                });
+                return success(responseId ?? recipient);
+            }
+            const phoneNumberId = firstNonEmpty(String(configManager.get('surfaces.whatsapp.phoneNumberId') ?? ''));
+            const accessToken = firstNonEmpty(await serviceRegistry.resolveSecret('whatsapp', 'primary'), String(configManager.get('surfaces.whatsapp.accessToken') ?? ''), process.env.WHATSAPP_ACCESS_TOKEN);
+            if (!phoneNumberId)
+                throw new Error('Missing WhatsApp phone number id');
+            if (!accessToken)
+                throw new Error('Missing WhatsApp access token');
+            const apiBaseUrl = firstNonEmpty(process.env.WHATSAPP_BASE_URL, 'https://graph.facebook.com/v17.0');
+            const response = await fetch(`${normalizeBaseUrl(apiBaseUrl)}/${encodeURIComponent(phoneNumberId)}/messages`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${accessToken}`,
+                },
+                body: JSON.stringify({
+                    messaging_product: 'whatsapp',
+                    recipient_type: 'individual',
+                    to: recipient,
+                    type: 'text',
+                    text: {
+                        preview_url: true,
+                        body: trimForSurface(appendAttachmentSummary(request.body, attachments), 4_096),
+                    },
+                }),
+            });
+            const payload = await requireOkResponse('WhatsApp delivery failed', response);
+            return success(extractResponseId(payload) ?? recipient);
+        },
+    };
+}
+export function createIMessageDeliveryStrategy(configManager, serviceRegistry, artifactStore) {
+    return {
+        id: 'channel-delivery:imessage',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'imessage';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager);
+            const bridgeUrl = firstNonEmpty(request.target.address?.startsWith('https://') ? request.target.address : undefined, String(configManager.get('surfaces.imessage.bridgeUrl') ?? ''), serviceRegistry.get('imessage')?.baseUrl, process.env.IMESSAGE_BRIDGE_URL);
+            const chatId = firstNonEmpty(request.target.address?.startsWith('https://') ? undefined : request.target.address, request.binding?.channelId, request.binding?.externalId, String(configManager.get('surfaces.imessage.defaultChatId') ?? ''));
+            if (!bridgeUrl)
+                throw new Error('Missing iMessage bridge URL');
+            if (!chatId)
+                throw new Error('Missing iMessage chat id');
+            const token = firstNonEmpty(await serviceRegistry.resolveSecret('imessage', 'primary'), String(configManager.get('surfaces.imessage.token') ?? ''), process.env.IMESSAGE_BRIDGE_TOKEN);
+            const responseId = await postBridgePayload(bridgeUrl, {
+                surface: 'imessage',
+                account: firstNonEmpty(String(configManager.get('surfaces.imessage.account') ?? '')),
+                chatId,
+                text: trimForSurface(appendAttachmentSummary(request.body, attachments), 8_000),
+                title: request.title,
+                jobId: request.jobId,
+                runId: request.runId,
+                routeId: request.binding?.id,
+                threadId: request.binding?.threadId,
+                attachments,
+            }, {
+                label: 'iMessage bridge delivery failed',
+                token,
+            });
+            return success(responseId ?? chatId);
+        },
+    };
+}
+export function createBlueBubblesDeliveryStrategy(configManager, serviceRegistry, artifactStore) {
+    return {
+        id: 'channel-delivery:bluebubbles',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'bluebubbles';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager, 128 * 1024);
+            const serverUrl = firstNonEmpty(String(configManager.get('surfaces.bluebubbles.serverUrl') ?? ''), serviceRegistry.get('bluebubbles')?.baseUrl, process.env.BLUEBUBBLES_SERVER_URL);
+            const password = firstNonEmpty(await serviceRegistry.resolveSecret('bluebubbles', 'password'), String(configManager.get('surfaces.bluebubbles.password') ?? ''), process.env.BLUEBUBBLES_PASSWORD);
+            const chatGuid = firstNonEmpty(request.target.address, typeof request.binding?.metadata.chatGuid === 'string' ? request.binding.metadata.chatGuid : undefined, request.binding?.channelId, request.binding?.externalId, String(configManager.get('surfaces.bluebubbles.defaultChatGuid') ?? ''));
+            if (!serverUrl)
+                throw new Error('Missing BlueBubbles server URL');
+            if (!password)
+                throw new Error('Missing BlueBubbles password');
+            if (!chatGuid)
+                throw new Error('Missing BlueBubbles chat guid');
+            const response = await fetch(`${normalizeBaseUrl(serverUrl)}/api/v1/message/text?password=${encodeURIComponent(password)}`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    chatGuid,
+                    tempGuid: crypto.randomUUID(),
+                    message: trimForSurface(appendAttachmentSummary(request.body, attachments), 8_000),
+                }),
+            });
+            const payload = await requireOkResponse('BlueBubbles delivery failed', response);
+            return success(extractResponseId(payload) ?? chatGuid);
+        },
+    };
+}

package/dist/_internal/platform/channels/delivery/strategies-core.d.ts

@@ -0,0 +1,13 @@
+import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import { ConfigManager } from '../../config/manager.js';
+import { ServiceRegistry } from '../../config/service-registry.js';
+import { ControlPlaneGateway } from '../../control-plane/gateway.js';
+import type { ChannelDeliveryStrategy } from './types.js';
+export declare function createWebhookDeliveryStrategy(configManager: ConfigManager, artifactStore: ArtifactStore): ChannelDeliveryStrategy;
+export declare function createSlackDeliveryStrategy(serviceRegistry: ServiceRegistry, configManager: ConfigManager, artifactStore: ArtifactStore): ChannelDeliveryStrategy;
+export declare function createDiscordDeliveryStrategy(serviceRegistry: ServiceRegistry, configManager: ConfigManager, artifactStore: ArtifactStore): ChannelDeliveryStrategy;
+export declare function createNtfyDeliveryStrategy(configManager: ConfigManager, serviceRegistry: ServiceRegistry, artifactStore: ArtifactStore): ChannelDeliveryStrategy;
+export declare function createWebControlPlaneDeliveryStrategy(configManager: ConfigManager, artifactStore: ArtifactStore, getGateway: () => ControlPlaneGateway | null): ChannelDeliveryStrategy;
+export declare function createTelegramDeliveryStrategy(configManager: ConfigManager, serviceRegistry: ServiceRegistry, artifactStore: ArtifactStore): ChannelDeliveryStrategy;
+export declare function createGoogleChatDeliveryStrategy(configManager: ConfigManager, serviceRegistry: ServiceRegistry, artifactStore: ArtifactStore): ChannelDeliveryStrategy;
+//# sourceMappingURL=strategies-core.d.ts.map

package/dist/_internal/platform/channels/delivery/strategies-core.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategies-core.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/channels/delivery/strategies-core.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAGrE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAa1D,wBAAgB,6BAA6B,CAAC,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,GAAG,uBAAuB,CAsCjI;AAED,wBAAgB,2BAA2B,CACzC,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,EAC5B,aAAa,EAAE,aAAa,GAC3B,uBAAuB,CA0CzB;AAED,wBAAgB,6BAA6B,CAC3C,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,EAC5B,aAAa,EAAE,aAAa,GAC3B,uBAAuB,CA2CzB;AAED,wBAAgB,0BAA0B,CACxC,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,GAC3B,uBAAuB,CAuBzB;AAED,wBAAgB,qCAAqC,CACnD,aAAa,EAAE,aAAa,EAC5B,aAAa,EAAE,aAAa,EAC5B,UAAU,EAAE,MAAM,mBAAmB,GAAG,IAAI,GAC3C,uBAAuB,CA6BzB;AAED,wBAAgB,8BAA8B,CAC5C,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,GAC3B,uBAAuB,CAqCzB;AAED,wBAAgB,gCAAgC,CAC9C,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,GAC3B,uBAAuB,CA+BzB"}

package/dist/_internal/platform/channels/delivery/strategies-core.js

@@ -0,0 +1,238 @@
+import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import { ConfigManager } from '../../config/manager.js';
+import { ServiceRegistry } from '../../config/service-registry.js';
+import { ControlPlaneGateway } from '../../control-plane/gateway.js';
+import { DiscordIntegration, NtfyIntegration, SlackIntegration } from '../../integrations/index.js';
+import { validatePublicWebhookUrl } from '@pellux/goodvibes-sdk/platform/utils/url-safety';
+import { appendAttachmentSummary, extractResponseId, firstNonEmpty, requireOkResponse, resolveAttachments, resolveChannelDeliverySurfaceKind, success, titleFromBody, trimForSurface, } from './shared.js';
+export function createWebhookDeliveryStrategy(configManager, artifactStore) {
+    return {
+        id: 'channel-delivery:webhook',
+        canHandle(request) {
+            return request.target.kind === 'webhook' || resolveChannelDeliverySurfaceKind(request.target) === 'webhook';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager, 128 * 1024);
+            const address = request.target.address
+                ?? (typeof request.binding?.metadata.callbackUrl === 'string' ? request.binding.metadata.callbackUrl : undefined)
+                ?? String(configManager.get('surfaces.webhook.defaultTarget') ?? '');
+            if (!address)
+                throw new Error('Missing webhook delivery target');
+            const validation = validatePublicWebhookUrl(address);
+            if (!validation.ok)
+                throw new Error(validation.error);
+            const timeoutMs = Number(configManager.get('surfaces.webhook.timeoutMs') ?? 15_000);
+            const response = await fetch(validation.url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                signal: AbortSignal.timeout(timeoutMs),
+                body: JSON.stringify({
+                    text: request.body,
+                    message: request.body,
+                    title: request.title,
+                    jobId: request.jobId,
+                    runId: request.runId,
+                    routeId: request.binding?.id,
+                    attachments,
+                    artifacts: attachments,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${await response.text().catch(() => '')}`);
+            }
+            return success(validation.url);
+        },
+    };
+}
+export function createSlackDeliveryStrategy(serviceRegistry, configManager, artifactStore) {
+    return {
+        id: 'channel-delivery:slack',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'slack';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager);
+            const bodyWithAttachments = appendAttachmentSummary(request.body, attachments);
+            const webhookUrl = await serviceRegistry.resolveSecret('slack', 'webhookUrl')
+                ?? process.env.SLACK_WEBHOOK_URL;
+            const botToken = await serviceRegistry.resolveSecret('slack', 'primary')
+                ?? process.env.SLACK_BOT_TOKEN;
+            const slack = new SlackIntegration(webhookUrl ?? undefined, botToken ?? undefined);
+            const responseUrl = typeof request.binding?.metadata.responseUrl === 'string'
+                ? request.binding.metadata.responseUrl
+                : undefined;
+            if (responseUrl?.startsWith('https://hooks.slack.com/')) {
+                await fetch(responseUrl, {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({
+                        response_type: 'in_channel',
+                        blocks: slack.formatAgentResult(request.agentId ?? request.runId, request.title, bodyWithAttachments),
+                    }),
+                });
+                return success(responseUrl);
+            }
+            if (request.target.address?.startsWith('https://')) {
+                await slack.postWebhook(bodyWithAttachments, undefined, request.target.address);
+                return success(request.target.address);
+            }
+            if (request.target.address) {
+                await slack.postMessage(request.target.address, bodyWithAttachments);
+                return success(request.target.address);
+            }
+            await slack.postWebhook(bodyWithAttachments);
+            return success(webhookUrl ?? undefined);
+        },
+    };
+}
+export function createDiscordDeliveryStrategy(serviceRegistry, configManager, artifactStore) {
+    return {
+        id: 'channel-delivery:discord',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'discord';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager);
+            const bodyWithAttachments = appendAttachmentSummary(request.body, attachments);
+            const webhookUrl = await serviceRegistry.resolveSecret('discord', 'webhookUrl')
+                ?? process.env.DISCORD_WEBHOOK_URL;
+            const botToken = await serviceRegistry.resolveSecret('discord', 'primary')
+                ?? process.env.DISCORD_BOT_TOKEN;
+            const discord = new DiscordIntegration(webhookUrl ?? undefined, botToken ?? undefined);
+            const applicationId = typeof request.binding?.metadata.applicationId === 'string'
+                ? request.binding.metadata.applicationId
+                : undefined;
+            const interactionToken = typeof request.binding?.metadata.interactionToken === 'string'
+                ? request.binding.metadata.interactionToken
+                : undefined;
+            if (applicationId && interactionToken) {
+                await discord.editOriginalResponse(applicationId, interactionToken, '', [discord.formatAgentResult(request.agentId ?? request.runId, request.title, bodyWithAttachments)]);
+                return success(`${applicationId}:${interactionToken}`);
+            }
+            if (request.target.address?.startsWith('https://')) {
+                await discord.postWebhook(bodyWithAttachments, undefined, request.target.address);
+                return success(request.target.address);
+            }
+            if (request.target.address) {
+                await discord.postMessage(request.target.address, bodyWithAttachments);
+                return success(request.target.address);
+            }
+            await discord.postWebhook(bodyWithAttachments);
+            return success(webhookUrl ?? undefined);
+        },
+    };
+}
+export function createNtfyDeliveryStrategy(configManager, serviceRegistry, artifactStore) {
+    return {
+        id: 'channel-delivery:ntfy',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'ntfy';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager);
+            const baseUrl = String(configManager.get('surfaces.ntfy.baseUrl') ?? 'https://ntfy.sh');
+            const token = await serviceRegistry.resolveSecret('ntfy', 'primary') ?? process.env.NTFY_ACCESS_TOKEN;
+            const topic = request.target.address ?? String(configManager.get('surfaces.ntfy.topic') ?? '');
+            if (!topic)
+                throw new Error('Missing ntfy topic');
+            const ntfy = new NtfyIntegration(baseUrl, token ?? undefined);
+            const baseUrlHint = String(configManager.get('controlPlane.baseUrl') ?? configManager.get('web.publicBaseUrl') ?? '');
+            const primaryAttachment = attachments[0];
+            await ntfy.publish(topic, appendAttachmentSummary(request.body, attachments), {
+                title: request.target.label ?? titleFromBody(request.body),
+                ...(request.includeLinks && baseUrlHint ? { click: `${baseUrlHint.replace(/\/+$/, '')}/api/control-plane/web` } : {}),
+                ...(primaryAttachment?.contentUrl ? { attach: primaryAttachment.contentUrl } : {}),
+            });
+            return success(topic);
+        },
+    };
+}
+export function createWebControlPlaneDeliveryStrategy(configManager, artifactStore, getGateway) {
+    return {
+        id: 'channel-delivery:web-control-plane',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'web';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager);
+            const gateway = getGateway();
+            if (!gateway) {
+                throw new Error('Web control-plane gateway unavailable');
+            }
+            const published = gateway.publishSurfaceMessage({
+                surface: 'web',
+                title: request.target.label ?? request.title,
+                body: request.body,
+                level: request.status === 'failed' ? 'error' : request.status === 'completed' ? 'success' : 'info',
+                routeId: request.binding?.id ?? request.target.routeId,
+                surfaceId: request.binding?.surfaceId,
+                attachments,
+                metadata: {
+                    jobId: request.jobId,
+                    runId: request.runId,
+                    agentId: request.agentId,
+                },
+            });
+            return success(published.id);
+        },
+    };
+}
+export function createTelegramDeliveryStrategy(configManager, serviceRegistry, artifactStore) {
+    return {
+        id: 'channel-delivery:telegram',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'telegram';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager);
+            const token = firstNonEmpty(await serviceRegistry.resolveSecret('telegram', 'primary'), String(configManager.get('surfaces.telegram.botToken') ?? ''), process.env.TELEGRAM_BOT_TOKEN);
+            const chatId = firstNonEmpty(request.target.address, request.binding?.channelId, request.binding?.externalId, String(configManager.get('surfaces.telegram.defaultChatId') ?? ''));
+            if (!token)
+                throw new Error('Missing Telegram bot token');
+            if (!chatId)
+                throw new Error('Missing Telegram chat id');
+            const response = await fetch(`https://api.telegram.org/bot${encodeURIComponent(token)}/sendMessage`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                body: JSON.stringify({
+                    chat_id: chatId,
+                    text: trimForSurface(appendAttachmentSummary(request.body, attachments), 4_096),
+                    disable_web_page_preview: true,
+                    ...(request.binding?.threadId && /^\d+$/.test(request.binding.threadId)
+                        ? { message_thread_id: Number(request.binding.threadId) }
+                        : {}),
+                }),
+            });
+            const payload = await requireOkResponse('Telegram delivery failed', response);
+            return success(extractResponseId(payload) ?? chatId);
+        },
+    };
+}
+export function createGoogleChatDeliveryStrategy(configManager, serviceRegistry, artifactStore) {
+    return {
+        id: 'channel-delivery:google-chat',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'google-chat';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager);
+            const webhookUrl = firstNonEmpty(request.target.address?.startsWith('https://') ? request.target.address : undefined, await serviceRegistry.resolveSecret('google-chat', 'webhookUrl'), serviceRegistry.get('google-chat')?.baseUrl, String(configManager.get('surfaces.googleChat.webhookUrl') ?? ''), process.env.GOOGLE_CHAT_WEBHOOK_URL);
+            if (!webhookUrl) {
+                throw new Error('Missing Google Chat webhook URL');
+            }
+            const threadKey = firstNonEmpty(request.binding?.threadId, request.binding?.channelId, request.binding?.externalId);
+            const response = await fetch(webhookUrl, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json; charset=UTF-8' },
+                body: JSON.stringify({
+                    text: trimForSurface(appendAttachmentSummary(request.body, attachments), 4_000),
+                    ...(threadKey ? { thread: { threadKey } } : {}),
+                }),
+            });
+            const payload = await requireOkResponse('Google Chat delivery failed', response);
+            return success(extractResponseId(payload) ?? webhookUrl);
+        },
+    };
+}

package/dist/_internal/platform/channels/delivery/strategies-enterprise.d.ts

@@ -0,0 +1,8 @@
+import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import { ConfigManager } from '../../config/manager.js';
+import { ServiceRegistry } from '../../config/service-registry.js';
+import type { ChannelDeliveryStrategy } from './types.js';
+export declare function createMSTeamsDeliveryStrategy(configManager: ConfigManager, serviceRegistry: ServiceRegistry, artifactStore: ArtifactStore): ChannelDeliveryStrategy;
+export declare function createMattermostDeliveryStrategy(configManager: ConfigManager, serviceRegistry: ServiceRegistry, artifactStore: ArtifactStore): ChannelDeliveryStrategy;
+export declare function createMatrixDeliveryStrategy(configManager: ConfigManager, serviceRegistry: ServiceRegistry, artifactStore: ArtifactStore): ChannelDeliveryStrategy;
+//# sourceMappingURL=strategies-enterprise.d.ts.map

package/dist/_internal/platform/channels/delivery/strategies-enterprise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strategies-enterprise.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/channels/delivery/strategies-enterprise.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACnE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,YAAY,CAAC;AAc1D,wBAAgB,6BAA6B,CAC3C,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,GAC3B,uBAAuB,CA+CzB;AAED,wBAAgB,gCAAgC,CAC9C,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,GAC3B,uBAAuB,CA2CzB;AAED,wBAAgB,4BAA4B,CAC1C,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,eAAe,EAChC,aAAa,EAAE,aAAa,GAC3B,uBAAuB,CAsDzB"}

package/dist/_internal/platform/channels/delivery/strategies-enterprise.js

@@ -0,0 +1,120 @@
+import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import { ConfigManager } from '../../config/manager.js';
+import { ServiceRegistry } from '../../config/service-registry.js';
+import { appendAttachmentSummary, extractResponseId, firstNonEmpty, normalizeBaseUrl, requireOkResponse, resolveAttachments, resolveChannelDeliverySurfaceKind, resolveMSTeamsAccessToken, success, trimForSurface, } from './shared.js';
+export function createMSTeamsDeliveryStrategy(configManager, serviceRegistry, artifactStore) {
+    return {
+        id: 'channel-delivery:msteams',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'msteams';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager, 128 * 1024);
+            const serviceUrl = firstNonEmpty(typeof request.binding?.metadata.serviceUrl === 'string' ? request.binding.metadata.serviceUrl : undefined, String(configManager.get('surfaces.msteams.serviceUrl') ?? ''), process.env.MSTEAMS_SERVICE_URL);
+            const rawConversationId = firstNonEmpty(request.target.address, typeof request.binding?.metadata.conversationId === 'string' ? request.binding.metadata.conversationId : undefined, request.binding?.channelId, request.binding?.externalId, String(configManager.get('surfaces.msteams.defaultConversationId') ?? ''));
+            if (!serviceUrl)
+                throw new Error('Missing Microsoft Teams service URL');
+            if (!rawConversationId)
+                throw new Error('Missing Microsoft Teams conversation id');
+            const threadId = firstNonEmpty(request.binding?.threadId, typeof request.binding?.metadata.replyToId === 'string' ? request.binding.metadata.replyToId : undefined);
+            const conversationId = threadId && !rawConversationId.includes(';messageid=')
+                ? `${rawConversationId};messageid=${threadId}`
+                : rawConversationId;
+            const accessToken = await resolveMSTeamsAccessToken(configManager, serviceRegistry);
+            const response = await fetch(`${normalizeBaseUrl(serviceUrl)}/v3/conversations/${encodeURIComponent(conversationId)}/activities`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${accessToken}`,
+                },
+                body: JSON.stringify({
+                    type: 'message',
+                    text: trimForSurface(appendAttachmentSummary(request.body, attachments), 4_000),
+                    textFormat: 'plain',
+                    ...(threadId ? { replyToId: threadId } : {}),
+                }),
+            });
+            const payload = await requireOkResponse('Microsoft Teams delivery failed', response);
+            return success(extractResponseId(payload) ?? conversationId);
+        },
+    };
+}
+export function createMattermostDeliveryStrategy(configManager, serviceRegistry, artifactStore) {
+    return {
+        id: 'channel-delivery:mattermost',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'mattermost';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager, 128 * 1024);
+            const baseUrl = firstNonEmpty(String(configManager.get('surfaces.mattermost.baseUrl') ?? ''), serviceRegistry.get('mattermost')?.baseUrl, process.env.MATTERMOST_BASE_URL);
+            const botToken = firstNonEmpty(await serviceRegistry.resolveSecret('mattermost', 'primary'), String(configManager.get('surfaces.mattermost.botToken') ?? ''), process.env.MATTERMOST_BOT_TOKEN);
+            const channelId = firstNonEmpty(request.target.address, request.binding?.channelId, request.binding?.externalId, String(configManager.get('surfaces.mattermost.defaultChannelId') ?? ''));
+            if (!baseUrl)
+                throw new Error('Missing Mattermost base URL');
+            if (!botToken)
+                throw new Error('Missing Mattermost bot token');
+            if (!channelId)
+                throw new Error('Missing Mattermost channel id');
+            const response = await fetch(`${normalizeBaseUrl(baseUrl)}/api/v4/posts`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${botToken}`,
+                },
+                body: JSON.stringify({
+                    channel_id: channelId,
+                    message: trimForSurface(appendAttachmentSummary(request.body, attachments), 12_000),
+                    ...(request.binding?.threadId ? { root_id: request.binding.threadId } : {}),
+                }),
+            });
+            const payload = await requireOkResponse('Mattermost delivery failed', response);
+            return success(extractResponseId(payload) ?? channelId);
+        },
+    };
+}
+export function createMatrixDeliveryStrategy(configManager, serviceRegistry, artifactStore) {
+    return {
+        id: 'channel-delivery:matrix',
+        canHandle(request) {
+            return resolveChannelDeliverySurfaceKind(request.target) === 'matrix';
+        },
+        async deliver(request) {
+            const attachments = await resolveAttachments(request, artifactStore, configManager, 128 * 1024);
+            const homeserverUrl = firstNonEmpty(String(configManager.get('surfaces.matrix.homeserverUrl') ?? ''), serviceRegistry.get('matrix')?.baseUrl, process.env.MATRIX_HOMESERVER);
+            const accessToken = firstNonEmpty(await serviceRegistry.resolveSecret('matrix', 'primary'), String(configManager.get('surfaces.matrix.accessToken') ?? ''), process.env.MATRIX_ACCESS_TOKEN);
+            const roomId = firstNonEmpty(request.target.address, request.binding?.channelId, request.binding?.externalId, String(configManager.get('surfaces.matrix.defaultRoomId') ?? ''));
+            if (!homeserverUrl)
+                throw new Error('Missing Matrix homeserver URL');
+            if (!accessToken)
+                throw new Error('Missing Matrix access token');
+            if (!roomId)
+                throw new Error('Missing Matrix room id');
+            const txnId = crypto.randomUUID();
+            const threadId = request.binding?.threadId;
+            const response = await fetch(`${normalizeBaseUrl(homeserverUrl)}/_matrix/client/v3/rooms/${encodeURIComponent(roomId)}/send/m.room.message/${encodeURIComponent(txnId)}`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    Authorization: `Bearer ${accessToken}`,
+                },
+                body: JSON.stringify({
+                    msgtype: 'm.text',
+                    body: trimForSurface(appendAttachmentSummary(request.body, attachments), 8_000),
+                    ...(threadId
+                        ? {
+                            'm.relates_to': {
+                                rel_type: 'm.thread',
+                                event_id: threadId,
+                                is_falling_back: true,
+                                'm.in_reply_to': { event_id: threadId },
+                            },
+                        }
+                        : {}),
+                }),
+            });
+            const payload = await requireOkResponse('Matrix delivery failed', response);
+            return success(extractResponseId(payload) ?? roomId);
+        },
+    };
+}

package/dist/_internal/platform/channels/delivery/types.d.ts

@@ -0,0 +1,53 @@
+import type { ArtifactReference } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import type { ConfigManager } from '../../config/manager.js';
+import type { ServiceRegistry } from '../../config/service-registry.js';
+import type { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import type { ControlPlaneGateway } from '../../control-plane/gateway.js';
+import type { RouteSurfaceKind } from '@pellux/goodvibes-sdk/platform/runtime/events/routes';
+export type ChannelDeliverySurfaceKind = RouteSurfaceKind;
+export type ChannelDeliveryTargetKind = 'none' | 'webhook' | 'surface' | 'integration' | 'link';
+export interface ChannelDeliveryTarget {
+    readonly kind: ChannelDeliveryTargetKind;
+    readonly surfaceKind?: ChannelDeliverySurfaceKind;
+    readonly address?: string;
+    readonly routeId?: string;
+    readonly label?: string;
+}
+export interface ChannelDeliveryRouteBinding {
+    readonly id: string;
+    readonly surfaceKind: ChannelDeliverySurfaceKind;
+    readonly surfaceId: string;
+    readonly externalId: string;
+    readonly threadId?: string;
+    readonly channelId?: string;
+    readonly title?: string;
+    readonly metadata: Record<string, unknown>;
+}
+export interface ChannelDeliveryRequest {
+    readonly target: ChannelDeliveryTarget;
+    readonly body: string;
+    readonly title: string;
+    readonly jobId: string;
+    readonly runId: string;
+    readonly agentId?: string;
+    readonly status?: string;
+    readonly includeLinks: boolean;
+    readonly attachments?: readonly ArtifactReference[];
+    readonly binding?: ChannelDeliveryRouteBinding;
+}
+export interface ChannelDeliveryResult {
+    readonly responseId?: string;
+}
+export interface ChannelDeliveryStrategy {
+    readonly id: string;
+    canHandle(request: ChannelDeliveryRequest): boolean;
+    deliver(request: ChannelDeliveryRequest): Promise<ChannelDeliveryResult>;
+}
+export interface ChannelDeliveryRouterConfig {
+    readonly configManager?: ConfigManager;
+    readonly serviceRegistry?: ServiceRegistry;
+    readonly artifactStore?: ArtifactStore;
+    readonly controlPlaneGateway?: ControlPlaneGateway | null;
+    readonly strategies?: readonly ChannelDeliveryStrategy[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/_internal/platform/channels/delivery/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/channels/delivery/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gDAAgD,CAAC;AACxF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,yBAAyB,CAAC;AAC7D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gDAAgD,CAAC;AACpF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sDAAsD,CAAC;AAE7F,MAAM,MAAM,0BAA0B,GAAG,gBAAgB,CAAC;AAC1D,MAAM,MAAM,yBAAyB,GAAG,MAAM,GAAG,SAAS,GAAG,SAAS,GAAG,aAAa,GAAG,MAAM,CAAC;AAEhG,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IACzC,QAAQ,CAAC,WAAW,CAAC,EAAE,0BAA0B,CAAC;IAClD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,WAAW,EAAE,0BAA0B,CAAC;IACjD,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CAC5C;AAED,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,iBAAiB,EAAE,CAAC;IACpD,QAAQ,CAAC,OAAO,CAAC,EAAE,2BAA2B,CAAC;CAChD;AAED,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,SAAS,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC;IACpD,OAAO,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;CAC1E;AAED,MAAM,WAAW,2BAA2B;IAC1C,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;IACvC,QAAQ,CAAC,eAAe,CAAC,EAAE,eAAe,CAAC;IAC3C,QAAQ,CAAC,aAAa,CAAC,EAAE,aAAa,CAAC;IACvC,QAAQ,CAAC,mBAAmB,CAAC,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAC1D,QAAQ,CAAC,UAAU,CAAC,EAAE,SAAS,uBAAuB,EAAE,CAAC;CAC1D"}

package/dist/_internal/platform/channels/delivery/types.js

@@ -0,0 +1 @@
+export {};

package/dist/_internal/platform/channels/delivery-router.d.ts

@@ -0,0 +1,21 @@
+import { ArtifactStore } from '@pellux/goodvibes-sdk/platform/artifacts/index';
+import { ConfigManager } from '../config/manager.js';
+import { ServiceRegistry } from '../config/service-registry.js';
+import type { ControlPlaneGateway } from '../control-plane/gateway.js';
+import type { ChannelDeliveryRequest, ChannelDeliveryRouterConfig, ChannelDeliveryStrategy } from './delivery/types.js';
+export type { ChannelDeliveryResult, ChannelDeliveryRouteBinding, ChannelDeliveryRouterConfig, ChannelDeliveryStrategy, ChannelDeliverySurfaceKind, ChannelDeliveryTarget, ChannelDeliveryTargetKind, } from './delivery/types.js';
+export { resolveChannelDeliverySurfaceKind } from './delivery/shared.js';
+export declare function createDefaultChannelDeliveryStrategies(configManager: ConfigManager, serviceRegistry: ServiceRegistry, artifactStore: ArtifactStore, getControlPlaneGateway: () => ControlPlaneGateway | null): ChannelDeliveryStrategy[];
+export declare class ChannelDeliveryRouter {
+    private readonly strategies;
+    private controlPlaneGateway;
+    constructor(config?: ChannelDeliveryRouterConfig);
+    setControlPlaneGateway(gateway: ControlPlaneGateway | null): void;
+    listStrategies(): readonly ChannelDeliveryStrategy[];
+    registerStrategy(strategy: ChannelDeliveryStrategy, options?: {
+        readonly replace?: boolean;
+    }): void;
+    unregisterStrategy(strategyId: string): boolean;
+    deliver(request: ChannelDeliveryRequest): Promise<string | undefined>;
+}
+//# sourceMappingURL=delivery-router.d.ts.map