@pellux/goodvibes-sdk 0.18.14 → 0.18.15

package/dist/_internal/platform/channels/builtin/contracts.js

@@ -0,0 +1,299 @@
+import { ChannelPolicyManager } from '@pellux/goodvibes-sdk/platform/channels/policy-manager';
+import { CHANNEL_SETUP_VERSION, configSectionForSurface, } from './shared.js';
+import { renderBuiltinPolicy, surfaceLabelForBuiltin } from '@pellux/goodvibes-sdk/platform/channels/builtin/presentation';
+import { getBuiltinSetupSchema } from './setup-schema.js';
+export function buildBuiltinContractHooks(context, surface) {
+    return {
+        setupVersion: CHANNEL_SETUP_VERSION,
+        renderPolicy: () => renderBuiltinPolicy(surface),
+        getSetupSchema: () => getBuiltinSetupSchema(surface),
+        doctor: (accountId) => getBuiltinDoctorReport(context, surface, accountId),
+        listRepairActions: (accountId) => listBuiltinRepairActions(context, surface, accountId),
+        getLifecycleState: (accountId) => getBuiltinLifecycleState(context, surface, accountId),
+        migrateLifecycle: (accountId, input) => migrateBuiltinLifecycle(context, surface, accountId, input),
+        resolveAllowlist: (input) => resolveBuiltinAllowlist(context, surface, input),
+        editAllowlist: (input) => editBuiltinAllowlist(context, surface, input),
+    };
+}
+export async function listBuiltinRepairActions(context, surface, accountId) {
+    const account = accountId ? await context.resolveAccount(surface, accountId) : await context.buildAccount(surface);
+    const actions = (account?.actions ?? []).map((action) => ({
+        id: action.kind,
+        label: action.label,
+        description: `Run the ${action.kind} lifecycle action for ${surfaceLabelForBuiltin(surface)}.`,
+        dangerous: action.kind === 'disconnect' || action.kind === 'logout',
+        inputSchema: action.kind === 'disconnect' || action.kind === 'logout'
+            ? {
+                type: 'object',
+                properties: {
+                    confirm: { type: 'boolean' },
+                },
+                required: ['confirm'],
+            }
+            : undefined,
+        metadata: { actionId: action.id, available: action.available },
+    }));
+    const lifecycle = await getBuiltinLifecycleState(context, surface, accountId);
+    if (lifecycle.currentVersion < lifecycle.targetVersion) {
+        actions.push({
+            id: 'migrate-lifecycle',
+            label: 'Apply lifecycle migration',
+            description: `Advance ${surfaceLabelForBuiltin(surface)} setup metadata to version ${lifecycle.targetVersion}.`,
+            dangerous: false,
+            metadata: { fromVersion: lifecycle.currentVersion, toVersion: lifecycle.targetVersion },
+        });
+    }
+    return actions;
+}
+export async function getBuiltinDoctorReport(context, surface, accountId) {
+    const account = accountId ? await context.resolveAccount(surface, accountId) : await context.buildAccount(surface);
+    const effectiveAccount = account ?? await context.buildAccount(surface);
+    const lifecycle = await getBuiltinLifecycleState(context, surface, accountId);
+    const checks = [];
+    const pushCheck = (id, label, status, detail, repairActionId) => {
+        checks.push({ id, label, status, detail, ...(repairActionId ? { repairActionId } : {}), metadata: {} });
+    };
+    pushCheck('configured', 'Configuration present', effectiveAccount.configured ? 'pass' : 'fail', effectiveAccount.configured
+        ? 'Surface configuration or account identity is present.'
+        : 'No durable configuration is present for this surface.', effectiveAccount.configured ? undefined : 'setup');
+    pushCheck('credentials', 'Credentials linked', effectiveAccount.linked ? 'pass' : effectiveAccount.configured ? 'warn' : 'fail', effectiveAccount.linked
+        ? 'At least one secret source is available.'
+        : effectiveAccount.configured
+            ? 'Configuration exists but no linked credentials were detected.'
+            : 'No credentials were detected.', effectiveAccount.linked ? undefined : 'retest');
+    pushCheck('enabled', 'Surface enabled', effectiveAccount.enabled ? 'pass' : 'warn', effectiveAccount.enabled
+        ? 'Surface delivery is enabled for the current runtime.'
+        : 'Surface delivery is disabled until it is enabled in config or env.', effectiveAccount.enabled ? undefined : 'start');
+    pushCheck('lifecycle', 'Lifecycle version', lifecycle.currentVersion >= lifecycle.targetVersion ? 'pass' : 'warn', lifecycle.currentVersion >= lifecycle.targetVersion
+        ? `Setup metadata is at version ${lifecycle.currentVersion}.`
+        : `Setup metadata is at version ${lifecycle.currentVersion}; target is ${lifecycle.targetVersion}.`, lifecycle.currentVersion >= lifecycle.targetVersion ? undefined : 'migrate-lifecycle');
+    const surfaces = context.deps.configManager.getCategory('surfaces');
+    if (surface === 'telegram' && !surfaces.telegram.defaultChatId) {
+        pushCheck('default-target', 'Default chat id', 'warn', 'No default Telegram chat id is configured; direct delivery requires a chat id or route binding.', 'setup');
+    }
+    if (surface === 'google-chat' && !surfaces.googleChat.webhookUrl && !surfaces.googleChat.spaceId) {
+        pushCheck('space-routing', 'Space routing', 'warn', 'Google Chat has neither a webhook URL nor a default space id configured.', 'setup');
+    }
+    if (surface === 'signal' && !surfaces.signal.bridgeUrl) {
+        pushCheck('bridge-url', 'Bridge URL', 'fail', 'Signal requires a bridge URL.', 'setup');
+    }
+    if (surface === 'whatsapp' && !surfaces.whatsapp.phoneNumberId && surfaces.whatsapp.provider === 'meta-cloud') {
+        pushCheck('provider-shape', 'Provider metadata', 'warn', 'Meta Cloud mode works best with a phone number id configured.', 'setup');
+    }
+    if (surface === 'imessage' && !surfaces.imessage.bridgeUrl) {
+        pushCheck('bridge-url', 'Bridge URL', 'fail', 'iMessage requires a bridge URL or local companion endpoint.', 'setup');
+    }
+    if (surface === 'msteams' && !surfaces.msteams.appId) {
+        pushCheck('app-id', 'App id', 'fail', 'Microsoft Teams requires an app id.', 'setup');
+    }
+    if (surface === 'msteams' && !surfaces.msteams.serviceUrl && !surfaces.msteams.defaultConversationId) {
+        pushCheck('conversation-routing', 'Conversation routing', 'warn', 'Teams will deliver best after an inbound conversation reference has been captured or a default conversation id is configured.', 'setup');
+    }
+    if (surface === 'bluebubbles' && !surfaces.bluebubbles.serverUrl) {
+        pushCheck('server-url', 'Server URL', 'fail', 'BlueBubbles requires a server URL.', 'setup');
+    }
+    if (surface === 'mattermost' && !surfaces.mattermost.baseUrl) {
+        pushCheck('base-url', 'Base URL', 'fail', 'Mattermost requires a base URL.', 'setup');
+    }
+    if (surface === 'mattermost' && !surfaces.mattermost.defaultChannelId) {
+        pushCheck('default-channel', 'Default channel', 'warn', 'No default Mattermost channel id is configured; proactive delivery will require route bindings.', 'setup');
+    }
+    if (surface === 'matrix' && !surfaces.matrix.homeserverUrl) {
+        pushCheck('homeserver-url', 'Homeserver URL', 'fail', 'Matrix requires a homeserver URL.', 'setup');
+    }
+    const failures = checks.filter((check) => check.status === 'fail').length;
+    const warnings = checks.filter((check) => check.status === 'warn').length;
+    const summary = failures > 0
+        ? `${failures} failing checks and ${warnings} warnings.`
+        : warnings > 0
+            ? `${warnings} warnings; no failing checks.`
+            : 'All checks passed.';
+    return {
+        surface,
+        ...(accountId ? { accountId } : {}),
+        state: effectiveAccount.state,
+        summary,
+        checkedAt: Date.now(),
+        checks,
+        repairActions: await listBuiltinRepairActions(context, surface, accountId),
+        metadata: {
+            accountId: effectiveAccount.accountId ?? effectiveAccount.id,
+        },
+    };
+}
+export async function getBuiltinLifecycleState(context, surface, accountId) {
+    const currentVersion = getConfiguredSetupVersion(context, surface);
+    const migrations = currentVersion >= CHANNEL_SETUP_VERSION
+        ? [{
+                id: `${surface}:lifecycle:${currentVersion}`,
+                fromVersion: currentVersion,
+                toVersion: CHANNEL_SETUP_VERSION,
+                action: 'noop',
+                applied: true,
+                detail: 'Setup metadata is current.',
+                metadata: {},
+            }]
+        : [{
+                id: `${surface}:lifecycle:${currentVersion}->${CHANNEL_SETUP_VERSION}`,
+                fromVersion: currentVersion,
+                toVersion: CHANNEL_SETUP_VERSION,
+                action: 'migrate',
+                applied: false,
+                detail: 'Setup metadata needs to be upgraded to the current schema version.',
+                metadata: {},
+            }];
+    return {
+        surface,
+        ...(accountId ? { accountId } : {}),
+        currentVersion,
+        targetVersion: CHANNEL_SETUP_VERSION,
+        migrations,
+        metadata: {},
+    };
+}
+export async function migrateBuiltinLifecycle(context, surface, accountId, _input) {
+    if (surface === 'tui' || surface === 'web') {
+        return getBuiltinLifecycleState(context, surface, accountId);
+    }
+    const section = configSectionForSurface(surface);
+    const surfaces = context.deps.configManager.getCategory('surfaces');
+    const current = surfaces[section];
+    const normalized = surface === 'telegram'
+        ? { ...surfaces.telegram, mode: surfaces.telegram.mode || 'webhook', setupVersion: CHANNEL_SETUP_VERSION }
+        : surface === 'whatsapp'
+            ? { ...surfaces.whatsapp, provider: surfaces.whatsapp.provider || 'meta-cloud', setupVersion: CHANNEL_SETUP_VERSION }
+            : { ...current, setupVersion: CHANNEL_SETUP_VERSION };
+    context.deps.configManager.mergeCategory('surfaces', {
+        [section]: normalized,
+    });
+    return getBuiltinLifecycleState(context, surface, accountId);
+}
+export async function resolveBuiltinAllowlist(context, surface, input) {
+    const requested = [...(input.add ?? []), ...(input.remove ?? [])];
+    const resolved = [];
+    const unresolved = [];
+    const seen = new Set();
+    for (const rawInput of requested) {
+        const candidate = rawInput.trim();
+        if (!candidate || seen.has(candidate))
+            continue;
+        seen.add(candidate);
+        const target = await context.resolveTarget(surface, {
+            input: candidate,
+            createIfMissing: true,
+            ...(input.kind ? { preferredKind: preferredConversationKindForAllowlist(input.kind) } : {}),
+        });
+        if (!target) {
+            unresolved.push(candidate);
+            continue;
+        }
+        const kind = input.kind ?? allowlistTargetKindForResolvedTarget(target);
+        const id = allowlistTargetId(kind, target);
+        if (!id) {
+            unresolved.push(candidate);
+            continue;
+        }
+        resolved.push({
+            kind,
+            input: candidate,
+            id,
+            label: target.display ?? target.to,
+            metadata: { target },
+        });
+    }
+    return {
+        surface,
+        resolved,
+        unresolved,
+        metadata: {},
+    };
+}
+export async function editBuiltinAllowlist(context, surface, input) {
+    await context.channelPolicy.start();
+    const resolution = await resolveBuiltinAllowlist(context, surface, input);
+    const addInputs = new Set((input.add ?? []).map((value) => value.trim()).filter(Boolean));
+    const removeInputs = new Set((input.remove ?? []).map((value) => value.trim()).filter(Boolean));
+    const added = resolution.resolved.filter((entry) => addInputs.has(entry.input));
+    const removed = resolution.resolved.filter((entry) => removeInputs.has(entry.input));
+    const existing = context.channelPolicy.getPolicy(surface);
+    const scoped = Boolean(input.groupId || input.channelId || input.workspaceId);
+    if (scoped) {
+        const match = existing.groupPolicies.find((entry) => ((input.groupId && entry.groupId === input.groupId)
+            || (input.channelId && entry.channelId === input.channelId)
+            || (input.workspaceId && entry.workspaceId === input.workspaceId)));
+        const nextGroup = {
+            id: match?.id ?? `allowlist:${surface}:${input.groupId ?? input.channelId ?? input.workspaceId ?? 'scope'}`,
+            ...(match?.label ? { label: match.label } : {}),
+            ...(input.groupId ? { groupId: input.groupId } : match?.groupId ? { groupId: match.groupId } : {}),
+            ...(input.channelId ? { channelId: input.channelId } : match?.channelId ? { channelId: match.channelId } : {}),
+            ...(input.workspaceId ? { workspaceId: input.workspaceId } : match?.workspaceId ? { workspaceId: match.workspaceId } : {}),
+            allowlistUserIds: applyAllowlistChanges(match?.allowlistUserIds ?? [], added.filter((entry) => entry.kind === 'user').map((entry) => entry.id), removed.filter((entry) => entry.kind === 'user').map((entry) => entry.id)),
+            allowlistChannelIds: applyAllowlistChanges(match?.allowlistChannelIds ?? [], added.filter((entry) => entry.kind === 'channel').map((entry) => entry.id), removed.filter((entry) => entry.kind === 'channel').map((entry) => entry.id)),
+            allowlistGroupIds: applyAllowlistChanges(match?.allowlistGroupIds ?? [], added.filter((entry) => entry.kind === 'group').map((entry) => entry.id), removed.filter((entry) => entry.kind === 'group').map((entry) => entry.id)),
+            metadata: match?.metadata ?? {},
+        };
+        const updated = await context.channelPolicy.upsertPolicy(surface, {
+            groupPolicies: [
+                ...existing.groupPolicies.filter((entry) => entry.id !== nextGroup.id),
+                nextGroup,
+            ],
+        });
+        return {
+            surface,
+            updatedPolicy: updated,
+            resolution,
+            metadata: { scoped: true, groupPolicyId: nextGroup.id },
+        };
+    }
+    const updated = await context.channelPolicy.upsertPolicy(surface, {
+        allowlistUserIds: applyAllowlistChanges(existing.allowlistUserIds, added.filter((entry) => entry.kind === 'user').map((entry) => entry.id), removed.filter((entry) => entry.kind === 'user').map((entry) => entry.id)),
+        allowlistChannelIds: applyAllowlistChanges(existing.allowlistChannelIds, added.filter((entry) => entry.kind === 'channel').map((entry) => entry.id), removed.filter((entry) => entry.kind === 'channel').map((entry) => entry.id)),
+        allowlistGroupIds: applyAllowlistChanges(existing.allowlistGroupIds, added.filter((entry) => entry.kind === 'group').map((entry) => entry.id), removed.filter((entry) => entry.kind === 'group').map((entry) => entry.id)),
+    });
+    return {
+        surface,
+        updatedPolicy: updated,
+        resolution,
+        metadata: { scoped: false },
+    };
+}
+function getConfiguredSetupVersion(context, surface) {
+    if (surface === 'tui' || surface === 'web')
+        return CHANNEL_SETUP_VERSION;
+    const section = configSectionForSurface(surface);
+    const surfaces = context.deps.configManager.getCategory('surfaces');
+    return Number(surfaces[section].setupVersion ?? 0);
+}
+function applyAllowlistChanges(existing, add, remove) {
+    const next = new Set(existing);
+    for (const value of add) {
+        if (value.trim())
+            next.add(value.trim());
+    }
+    for (const value of remove) {
+        if (value.trim())
+            next.delete(value.trim());
+    }
+    return [...next].sort((a, b) => a.localeCompare(b));
+}
+function preferredConversationKindForAllowlist(kind) {
+    if (kind === 'user')
+        return 'direct';
+    if (kind === 'channel')
+        return 'channel';
+    return 'group';
+}
+function allowlistTargetKindForResolvedTarget(target) {
+    if (target.kind === 'direct')
+        return 'user';
+    if (target.kind === 'channel')
+        return 'channel';
+    return 'group';
+}
+function allowlistTargetId(kind, target) {
+    if (kind === 'user')
+        return target.to || null;
+    if (kind === 'channel')
+        return target.channelId ?? target.to ?? null;
+    return target.groupId ?? target.threadId ?? target.channelId ?? target.to ?? null;
+}

package/dist/_internal/platform/channels/builtin/plugins.d.ts

@@ -0,0 +1,25 @@
+import type { AutomationRouteBinding } from '@pellux/goodvibes-sdk/platform/automation/routes';
+import type { SharedApprovalRecord } from '../../control-plane/index.js';
+import type { ProviderRuntimeSurface } from '../provider-runtime.js';
+import type { ChannelAccountRecord, ChannelCapabilityDescriptor, ChannelDirectoryEntry, ChannelDirectoryQueryOptions, ChannelOperatorActionDescriptor, ChannelSurface, ChannelToolDescriptor } from '@pellux/goodvibes-sdk/platform/channels/types';
+import type { ChannelPlugin } from '../plugin-registry.js';
+import type { BuiltinChannelRuntimeDeps, ManagedSurface } from './shared.js';
+interface BuiltinPluginRegistrationContext {
+    readonly deps: BuiltinChannelRuntimeDeps;
+    readonly buildAccount: (surface: ChannelSurface) => Promise<ChannelAccountRecord>;
+    readonly resolveAccount: (surface: ChannelSurface, accountId: string) => Promise<ChannelAccountRecord | null>;
+    readonly listCapabilities: (surface: ChannelSurface) => Promise<ChannelCapabilityDescriptor[]>;
+    readonly listTools: (surface: ChannelSurface) => ChannelToolDescriptor[];
+    readonly runTool: (surface: ChannelSurface, toolId: string, input?: Record<string, unknown>) => Promise<unknown>;
+    readonly listOperatorActions: (surface: ChannelSurface) => ChannelOperatorActionDescriptor[];
+    readonly runOperatorAction: (surface: ChannelSurface, actionId: string, input?: Record<string, unknown>) => Promise<unknown>;
+    readonly buildContractHooks: (surface: ChannelSurface) => Pick<ChannelPlugin, 'setupVersion' | 'renderPolicy' | 'getSetupSchema' | 'doctor' | 'listRepairActions' | 'getLifecycleState' | 'migrateLifecycle' | 'resolveAllowlist' | 'editAllowlist'>;
+    readonly buildProductHooks: (surface: ChannelSurface) => Pick<ChannelPlugin, 'runAccountAction' | 'authorizeActorAction' | 'parseExplicitTarget' | 'inferTargetConversationKind' | 'resolveTarget' | 'resolveSessionTarget' | 'resolveParentConversationCandidates' | 'renderEvent' | 'listAgentTools'>;
+    readonly lookupDirectory: (surface: ManagedSurface, query: string, options?: ChannelDirectoryQueryOptions) => Promise<ChannelDirectoryEntry[]>;
+    readonly lookupRouteDirectory: (surface: ManagedSurface, query: string, options?: ChannelDirectoryQueryOptions) => Promise<ChannelDirectoryEntry[]>;
+    readonly notifyApprovalViaRouter: (surface: ChannelSurface, approval: SharedApprovalRecord, binding: AutomationRouteBinding) => Promise<void>;
+    readonly providerRuntimeStatus: (surface: ProviderRuntimeSurface) => unknown;
+}
+export declare function registerBuiltinChannelPlugins(context: BuiltinPluginRegistrationContext): void;
+export {};
+//# sourceMappingURL=plugins.d.ts.map

package/dist/_internal/platform/channels/builtin/plugins.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugins.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/channels/builtin/plugins.ts"],"names":[],"mappings":"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"}

package/dist/_internal/platform/channels/builtin/plugins.js

@@ -0,0 +1,225 @@
+import { handleBlueBubblesSurfaceWebhook, handleDiscordSurfaceWebhook, handleGenericWebhookSurface, handleGoogleChatSurfaceWebhook, handleIMessageSurfaceWebhook, handleMSTeamsSurfaceWebhook, handleMattermostSurfaceWebhook, handleMatrixSurfaceWebhook, handleNtfySurfaceWebhook, handleSignalSurfaceWebhook, handleSlackSurfaceWebhook, handleTelegramSurfaceWebhook, handleWhatsAppSurfaceWebhook, } from '../../adapters/index.js';
+export function registerBuiltinChannelPlugins(context) {
+    context.deps.channelPlugins.register({
+        id: 'surface:tui',
+        surface: 'tui',
+        displayName: 'Terminal UI',
+        capabilities: ['ingress', 'egress', 'session_binding', 'account_lifecycle', 'target_resolution', 'agent_tools'],
+        getStatus: async () => ({
+            id: 'surface:tui',
+            surface: 'tui',
+            label: 'Terminal UI',
+            state: 'healthy',
+            enabled: true,
+            metadata: {},
+        }),
+        listAccounts: async () => [await context.buildAccount('tui')],
+        getAccount: async (accountId) => context.resolveAccount('tui', accountId),
+        listCapabilities: async () => context.listCapabilities('tui'),
+        listTools: async () => context.listTools('tui'),
+        runTool: (toolId, input) => context.runTool('tui', toolId, input),
+        listOperatorActions: async () => context.listOperatorActions('tui'),
+        runOperatorAction: (actionId, input) => context.runOperatorAction('tui', actionId, input),
+        ...context.buildContractHooks('tui'),
+        ...context.buildProductHooks('tui'),
+        lookupDirectory: async (query) => query.trim()
+            ? [{ id: 'surface:tui', surface: 'tui', kind: 'service', label: 'Terminal UI', metadata: {} }]
+            : [],
+    });
+    context.deps.channelPlugins.register({
+        id: 'surface:web',
+        surface: 'web',
+        displayName: 'Web control plane',
+        capabilities: ['ingress', 'egress', 'threaded_reply', 'account_lifecycle', 'target_resolution', 'agent_tools'],
+        getStatus: async () => ({
+            id: 'surface:web',
+            surface: 'web',
+            label: 'Web control plane',
+            state: context.deps.configManager.get('web.enabled') || context.deps.configManager.get('controlPlane.enabled') ? 'healthy' : 'disabled',
+            enabled: Boolean(context.deps.configManager.get('web.enabled') || context.deps.configManager.get('controlPlane.enabled')),
+            metadata: {
+                baseUrl: context.deps.configManager.get('web.publicBaseUrl'),
+            },
+        }),
+        listAccounts: async () => [await context.buildAccount('web')],
+        getAccount: async (accountId) => context.resolveAccount('web', accountId),
+        listCapabilities: async () => context.listCapabilities('web'),
+        listTools: async () => context.listTools('web'),
+        runTool: (toolId, input) => context.runTool('web', toolId, input),
+        listOperatorActions: async () => context.listOperatorActions('web'),
+        runOperatorAction: (actionId, input) => context.runOperatorAction('web', actionId, input),
+        ...context.buildContractHooks('web'),
+        ...context.buildProductHooks('web'),
+        lookupDirectory: async () => [{ id: 'surface:web', surface: 'web', kind: 'service', label: 'Web control plane', metadata: {} }],
+    });
+    context.deps.channelPlugins.register({
+        id: 'surface:slack',
+        surface: 'slack',
+        displayName: 'Slack',
+        capabilities: ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'],
+        webhookPath: '/webhook/slack',
+        handleInbound: (req) => handleSlackSurfaceWebhook(req, context.deps.buildSurfaceAdapterContext()),
+        deliverReply: (pending, message) => context.deps.deliverSlackAgentReply(pending, message),
+        deliverProgress: (pending, progress) => context.deps.deliverSurfaceProgress(pending, progress),
+        notifyApproval: (approval, binding) => context.deps.deliverSlackApprovalUpdate(approval, binding),
+        getStatus: async () => ({
+            id: 'surface:slack',
+            surface: 'slack',
+            label: 'Slack',
+            state: context.deps.surfaceDeliveryEnabled('slack') ? 'healthy' : 'disabled',
+            enabled: context.deps.surfaceDeliveryEnabled('slack'),
+            accountId: String(context.deps.configManager.get('surfaces.slack.workspaceId') || ''),
+            metadata: {
+                defaultChannel: context.deps.configManager.get('surfaces.slack.defaultChannel'),
+                providerRuntime: context.providerRuntimeStatus('slack'),
+            },
+        }),
+        listAccounts: async () => [await context.buildAccount('slack')],
+        getAccount: async (accountId) => context.resolveAccount('slack', accountId),
+        listCapabilities: async () => context.listCapabilities('slack'),
+        listTools: async () => context.listTools('slack'),
+        runTool: (toolId, input) => context.runTool('slack', toolId, input),
+        listOperatorActions: async () => context.listOperatorActions('slack'),
+        runOperatorAction: (actionId, input) => context.runOperatorAction('slack', actionId, input),
+        ...context.buildContractHooks('slack'),
+        ...context.buildProductHooks('slack'),
+        lookupDirectory: async (query, options) => context.lookupDirectory('slack', query, options),
+    });
+    context.deps.channelPlugins.register({
+        id: 'surface:discord',
+        surface: 'discord',
+        displayName: 'Discord',
+        capabilities: ['ingress', 'egress', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'],
+        webhookPath: '/webhook/discord',
+        handleInbound: (req) => handleDiscordSurfaceWebhook(req, context.deps.buildSurfaceAdapterContext()),
+        deliverReply: (pending, message) => context.deps.deliverDiscordAgentReply(pending, message),
+        deliverProgress: (pending, progress) => context.deps.deliverSurfaceProgress(pending, progress),
+        notifyApproval: (approval, binding) => context.deps.deliverDiscordApprovalUpdate(approval, binding),
+        getStatus: async () => ({
+            id: 'surface:discord',
+            surface: 'discord',
+            label: 'Discord',
+            state: context.deps.surfaceDeliveryEnabled('discord') ? 'healthy' : 'disabled',
+            enabled: context.deps.surfaceDeliveryEnabled('discord'),
+            accountId: String(context.deps.configManager.get('surfaces.discord.applicationId') || ''),
+            metadata: {
+                defaultChannelId: context.deps.configManager.get('surfaces.discord.defaultChannelId'),
+                providerRuntime: context.providerRuntimeStatus('discord'),
+            },
+        }),
+        listAccounts: async () => [await context.buildAccount('discord')],
+        getAccount: async (accountId) => context.resolveAccount('discord', accountId),
+        listCapabilities: async () => context.listCapabilities('discord'),
+        listTools: async () => context.listTools('discord'),
+        runTool: (toolId, input) => context.runTool('discord', toolId, input),
+        listOperatorActions: async () => context.listOperatorActions('discord'),
+        runOperatorAction: (actionId, input) => context.runOperatorAction('discord', actionId, input),
+        ...context.buildContractHooks('discord'),
+        ...context.buildProductHooks('discord'),
+        lookupDirectory: async (query, options) => context.lookupDirectory('discord', query, options),
+    });
+    context.deps.channelPlugins.register({
+        id: 'surface:ntfy',
+        surface: 'ntfy',
+        displayName: 'ntfy',
+        capabilities: ['ingress', 'egress', 'delivery_only', 'account_lifecycle', 'target_resolution', 'agent_tools'],
+        webhookPath: '/webhook/ntfy',
+        handleInbound: (req) => handleNtfySurfaceWebhook(req, context.deps.buildSurfaceAdapterContext()),
+        deliverReply: (pending, message) => context.deps.deliverNtfyAgentReply(pending, message),
+        notifyApproval: (approval, binding) => context.deps.deliverNtfyApprovalUpdate(approval, binding),
+        getStatus: async () => ({
+            id: 'surface:ntfy',
+            surface: 'ntfy',
+            label: 'ntfy',
+            state: context.deps.surfaceDeliveryEnabled('ntfy') ? 'healthy' : 'disabled',
+            enabled: context.deps.surfaceDeliveryEnabled('ntfy'),
+            metadata: {
+                topic: context.deps.configManager.get('surfaces.ntfy.topic'),
+                baseUrl: context.deps.configManager.get('surfaces.ntfy.baseUrl'),
+                providerRuntime: context.providerRuntimeStatus('ntfy'),
+            },
+        }),
+        listAccounts: async () => [await context.buildAccount('ntfy')],
+        getAccount: async (accountId) => context.resolveAccount('ntfy', accountId),
+        listCapabilities: async () => context.listCapabilities('ntfy'),
+        listTools: async () => context.listTools('ntfy'),
+        runTool: (toolId, input) => context.runTool('ntfy', toolId, input),
+        listOperatorActions: async () => context.listOperatorActions('ntfy'),
+        runOperatorAction: (actionId, input) => context.runOperatorAction('ntfy', actionId, input),
+        ...context.buildContractHooks('ntfy'),
+        ...context.buildProductHooks('ntfy'),
+        lookupDirectory: async (query, options) => context.lookupDirectory('ntfy', query, options),
+    });
+    context.deps.channelPlugins.register({
+        id: 'surface:webhook',
+        surface: 'webhook',
+        displayName: 'Generic webhook',
+        capabilities: ['ingress', 'egress', 'delivery_only', 'account_lifecycle', 'target_resolution', 'agent_tools'],
+        webhookPath: '/webhook/generic',
+        handleInbound: (req) => handleGenericWebhookSurface(req, context.deps.buildGenericWebhookAdapterContext()),
+        deliverReply: (pending, message) => context.deps.deliverWebhookAgentReply(pending, message),
+        notifyApproval: (approval, binding) => context.deps.deliverWebhookApprovalUpdate(approval, binding),
+        getStatus: async () => ({
+            id: 'surface:webhook',
+            surface: 'webhook',
+            label: 'Generic webhook',
+            state: context.deps.surfaceDeliveryEnabled('webhook') ? 'healthy' : 'disabled',
+            enabled: context.deps.surfaceDeliveryEnabled('webhook'),
+            metadata: {
+                defaultTarget: context.deps.configManager.get('surfaces.webhook.defaultTarget'),
+            },
+        }),
+        listAccounts: async () => [await context.buildAccount('webhook')],
+        getAccount: async (accountId) => context.resolveAccount('webhook', accountId),
+        listCapabilities: async () => context.listCapabilities('webhook'),
+        listTools: async () => context.listTools('webhook'),
+        runTool: (toolId, input) => context.runTool('webhook', toolId, input),
+        listOperatorActions: async () => context.listOperatorActions('webhook'),
+        runOperatorAction: (actionId, input) => context.runOperatorAction('webhook', actionId, input),
+        ...context.buildContractHooks('webhook'),
+        ...context.buildProductHooks('webhook'),
+        lookupDirectory: async (query, options) => context.lookupRouteDirectory('webhook', query, options),
+    });
+    registerRouterBackedPlugin(context, 'telegram', 'Telegram', ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/telegram', handleTelegramSurfaceWebhook);
+    registerRouterBackedPlugin(context, 'google-chat', 'Google Chat', ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/google-chat', handleGoogleChatSurfaceWebhook);
+    registerRouterBackedPlugin(context, 'signal', 'Signal', ['ingress', 'egress', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/signal', handleSignalSurfaceWebhook);
+    registerRouterBackedPlugin(context, 'whatsapp', 'WhatsApp', ['ingress', 'egress', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/whatsapp', handleWhatsAppSurfaceWebhook);
+    registerRouterBackedPlugin(context, 'imessage', 'iMessage', ['ingress', 'egress', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/imessage', handleIMessageSurfaceWebhook);
+    registerRouterBackedPlugin(context, 'msteams', 'Microsoft Teams', ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/msteams', handleMSTeamsSurfaceWebhook);
+    registerRouterBackedPlugin(context, 'bluebubbles', 'BlueBubbles', ['ingress', 'egress', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/bluebubbles', handleBlueBubblesSurfaceWebhook);
+    registerRouterBackedPlugin(context, 'mattermost', 'Mattermost', ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/mattermost', handleMattermostSurfaceWebhook);
+    registerRouterBackedPlugin(context, 'matrix', 'Matrix', ['ingress', 'egress', 'threaded_reply', 'interactive_actions', 'account_lifecycle', 'target_resolution', 'agent_tools'], '/webhook/matrix', handleMatrixSurfaceWebhook);
+}
+function registerRouterBackedPlugin(context, surface, displayName, capabilities, webhookPath, handleInbound) {
+    context.deps.channelPlugins.register({
+        id: `surface:${surface}`,
+        surface,
+        displayName,
+        capabilities,
+        webhookPath,
+        handleInbound: (req) => handleInbound(req, context.deps.buildSurfaceAdapterContext()),
+        getStatus: async () => {
+            const account = await context.buildAccount(surface);
+            return {
+                id: `surface:${surface}`,
+                surface,
+                label: displayName,
+                state: account.state === 'healthy' ? 'healthy' : account.state === 'disabled' ? 'disabled' : 'degraded',
+                enabled: context.deps.surfaceDeliveryEnabled(surface),
+                accountId: account.accountId,
+                metadata: account.metadata,
+            };
+        },
+        listAccounts: async () => [await context.buildAccount(surface)],
+        getAccount: async (accountId) => context.resolveAccount(surface, accountId),
+        listCapabilities: async () => context.listCapabilities(surface),
+        listTools: async () => context.listTools(surface),
+        runTool: (toolId, input) => context.runTool(surface, toolId, input),
+        listOperatorActions: async () => context.listOperatorActions(surface),
+        runOperatorAction: (actionId, input) => context.runOperatorAction(surface, actionId, input),
+        notifyApproval: (approval, binding) => context.notifyApprovalViaRouter(surface, approval, binding),
+        ...context.buildContractHooks(surface),
+        ...context.buildProductHooks(surface),
+        lookupDirectory: async (query, options) => context.lookupDirectory(surface, query, options),
+    });
+}

package/dist/_internal/platform/channels/builtin/rendering.d.ts

@@ -0,0 +1,15 @@
+import type { AutomationRouteBinding } from '@pellux/goodvibes-sdk/platform/automation/routes';
+import type { SharedApprovalRecord } from '../../control-plane/index.js';
+import type { Tool } from '@pellux/goodvibes-sdk/platform/types/tools';
+import type { ChannelRenderRequest, ChannelRenderResult, ChannelSurface, ChannelToolDescriptor } from '@pellux/goodvibes-sdk/platform/channels/types';
+import type { BuiltinChannelRuntimeDeps } from './shared.js';
+interface BuiltinRenderingContext {
+    readonly deps: BuiltinChannelRuntimeDeps;
+    readonly listTools: (surface: ChannelSurface) => ChannelToolDescriptor[];
+    readonly runTool: (surface: ChannelSurface, toolId: string, input?: Record<string, unknown>) => Promise<unknown>;
+}
+export declare function renderBuiltinChannelEvent(context: BuiltinRenderingContext, surface: ChannelSurface, request: ChannelRenderRequest): Promise<ChannelRenderResult>;
+export declare function notifyBuiltinApprovalViaRouter(context: BuiltinRenderingContext, surface: ChannelSurface, approval: SharedApprovalRecord, binding: AutomationRouteBinding): Promise<void>;
+export declare function listBuiltinAgentTools(context: BuiltinRenderingContext, surface: ChannelSurface): readonly Tool[];
+export {};
+//# sourceMappingURL=rendering.d.ts.map

package/dist/_internal/platform/channels/builtin/rendering.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rendering.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/channels/builtin/rendering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,kDAAkD,CAAC;AAC/F,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,8BAA8B,CAAC;AACzE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,4CAA4C,CAAC;AAGvE,OAAO,KAAK,EACV,oBAAoB,EACpB,mBAAmB,EACnB,cAAc,EACd,qBAAqB,EACtB,MAAM,+CAA+C,CAAC;AACvD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AAE7D,UAAU,uBAAuB;IAC/B,QAAQ,CAAC,IAAI,EAAE,yBAAyB,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,CAAC,OAAO,EAAE,cAAc,KAAK,qBAAqB,EAAE,CAAC;IACzE,QAAQ,CAAC,OAAO,EAAE,CAAC,OAAO,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;CAClH;AAED,wBAAsB,yBAAyB,CAC7C,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,mBAAmB,CAAC,CAwB9B;AAED,wBAAsB,8BAA8B,CAClD,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,cAAc,EACvB,QAAQ,EAAE,oBAAoB,EAC9B,OAAO,EAAE,sBAAsB,GAC9B,OAAO,CAAC,IAAI,CAAC,CAiBf;AAED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,uBAAuB,EAChC,OAAO,EAAE,cAAc,GACtB,SAAS,IAAI,EAAE,CA0BjB"}