@xmoxmo/bncr 0.3.6 → 0.3.8

package/src/plugin/channel-components.ts

@@ -0,0 +1,289 @@
+import path from 'node:path';
+import type { OpenClawPluginApi } from 'openclaw/plugin-sdk/core';
+import { emitBncrLogLine } from '../core/logging.ts';
+import { formatDisplayScope, normalizeStoredSessionKey, parseRouteLike } from '../core/targets.ts';
+import type { BncrRoute } from '../core/types.ts';
+import type { BncrInboundParamsInput } from '../messaging/inbound/contracts.ts';
+import { dispatchBncrInbound } from '../messaging/inbound/dispatch.ts';
+import { parseBncrInboundParams } from '../messaging/inbound/parse.ts';
+import { OUTBOUND_FLUSH_REASON, OUTBOUND_FLUSH_TRIGGER } from '../messaging/outbound/reasons.ts';
+import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
+import { getOpenClawRuntimeConfig } from '../openclaw/config-runtime.ts';
+import { saveOpenClawChannelMediaBuffer } from '../openclaw/media-runtime.ts';
+import { createBncrChannelSendRuntime } from './channel-send.ts';
+import { createBncrConnectionHandlers } from './connection-handlers.ts';
+import { createBncrDiagnosticsHandlers } from './diagnostics-handlers.ts';
+import { createBncrFileInboundHandlers } from './file-inbound-handlers.ts';
+import { createBncrInboundHandlers } from './inbound-handlers.ts';
+
+export function createBncrConnectionHandlersComponent(
+  runtime: Parameters<typeof createBncrConnectionHandlers>[0],
+) {
+  return createBncrConnectionHandlers(runtime);
+}
+
+export function createBncrDiagnosticsHandlersComponent(
+  runtime: Parameters<typeof createBncrDiagnosticsHandlers>[0],
+) {
+  return createBncrDiagnosticsHandlers(runtime);
+}
+
+export function createBncrBridgeDiagnosticsHandlersComponent(runtime: {
+  getApi: () => OpenClawPluginApi;
+  channelId: string;
+  asString: (value: unknown, fallback?: string) => string;
+  now: () => number;
+  countInvalidOutboxSessionKeys: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['countInvalidOutboxSessionKeys'];
+  countLegacyAccountResidue: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['countLegacyAccountResidue'];
+  buildRuntimeStatusInput: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['buildRuntimeStatusInput'];
+  getAccountRuntimeSnapshot: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['getAccountRuntimeSnapshot'];
+  buildIntegratedDiagnostics: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['buildIntegratedDiagnostics'];
+  buildExtendedDiagnostics: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['buildExtendedDiagnostics'];
+  buildDownlinkHealth: Parameters<typeof createBncrDiagnosticsHandlers>[0]['buildDownlinkHealth'];
+  buildRuntimeFlags: Parameters<typeof createBncrDiagnosticsHandlers>[0]['buildRuntimeFlags'];
+  activeConnectionCount: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['activeConnectionCount'];
+  getMessageAckWaiterCount: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['getMessageAckWaiterCount'];
+  getFileAckWaiterCount: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['getFileAckWaiterCount'];
+  filterDeadLetterEntries: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['filterDeadLetterEntries'];
+  listDeadLetterEntries: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['listDeadLetterEntries'];
+  buildDeadLetterDiagnostics: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['buildDeadLetterDiagnostics'];
+  replaceDeadLetterEntries: Parameters<
+    typeof createBncrDiagnosticsHandlers
+  >[0]['replaceDeadLetterEntries'];
+  scheduleSave: Parameters<typeof createBncrDiagnosticsHandlers>[0]['scheduleSave'];
+  logDeadLetterSummary: Parameters<typeof createBncrDiagnosticsHandlers>[0]['logDeadLetterSummary'];
+  pluginRoot: string;
+}) {
+  const buildDiagnosticsRuntimeStatusInput = (
+    accountId: string,
+    overrides: {
+      running: boolean;
+      invalidOutboxSessionKeys?: number;
+      legacyAccountResidue?: number;
+    },
+  ) => ({
+    ...runtime.buildRuntimeStatusInput(accountId, overrides),
+    running: overrides.running,
+    channelRoot: resolveBncrChannelRoot(runtime.pluginRoot),
+  });
+
+  return createBncrDiagnosticsHandlers({
+    getApi: runtime.getApi,
+    channelId: runtime.channelId,
+    asString: runtime.asString,
+    now: runtime.now,
+    countInvalidOutboxSessionKeys: runtime.countInvalidOutboxSessionKeys,
+    countLegacyAccountResidue: runtime.countLegacyAccountResidue,
+    buildRuntimeStatusInput: buildDiagnosticsRuntimeStatusInput,
+    getAccountRuntimeSnapshot: (accountId, runtimeStatusInput) =>
+      runtime.getAccountRuntimeSnapshot(
+        accountId,
+        runtimeStatusInput || buildDiagnosticsRuntimeStatusInput(accountId, { running: true }),
+      ),
+    buildIntegratedDiagnostics: (accountId, runtimeStatusInput) =>
+      runtime.buildIntegratedDiagnostics(
+        accountId,
+        runtimeStatusInput || buildDiagnosticsRuntimeStatusInput(accountId, { running: true }),
+      ),
+    buildExtendedDiagnostics: (accountId, args) =>
+      runtime.buildExtendedDiagnostics(accountId, {
+        runtimeStatusInput:
+          args?.runtimeStatusInput ||
+          buildDiagnosticsRuntimeStatusInput(accountId, { running: true }),
+        integratedDiagnostics:
+          args?.integratedDiagnostics ||
+          runtime.buildIntegratedDiagnostics(
+            accountId,
+            buildDiagnosticsRuntimeStatusInput(accountId, { running: true }),
+          ),
+      }),
+    buildDownlinkHealth: runtime.buildDownlinkHealth,
+    buildRuntimeFlags: runtime.buildRuntimeFlags,
+    activeConnectionCount: runtime.activeConnectionCount,
+    getMessageAckWaiterCount: runtime.getMessageAckWaiterCount,
+    getFileAckWaiterCount: runtime.getFileAckWaiterCount,
+    filterDeadLetterEntries: runtime.filterDeadLetterEntries,
+    listDeadLetterEntries: runtime.listDeadLetterEntries,
+    buildDeadLetterDiagnostics: runtime.buildDeadLetterDiagnostics,
+    replaceDeadLetterEntries: runtime.replaceDeadLetterEntries,
+    scheduleSave: runtime.scheduleSave,
+    logDeadLetterSummary: runtime.logDeadLetterSummary,
+  });
+}
+
+export function createBncrFileInboundHandlersComponent(runtime: {
+  getApi: () => OpenClawPluginApi;
+  asString: (value: unknown, fallback?: string) => string;
+  now: () => number;
+  normalizeAccountId: (accountId: string) => string;
+  finiteNonNegativeNumberOrNull: (value: unknown) => number | null;
+  shouldIgnoreStaleEvent: Parameters<
+    typeof createBncrFileInboundHandlers
+  >[0]['shouldIgnoreStaleEvent'];
+  observeLease: Parameters<typeof createBncrFileInboundHandlers>[0]['observeLease'];
+  matchesTransferOwner: Parameters<typeof createBncrFileInboundHandlers>[0]['matchesTransferOwner'];
+  refreshAcceptedFileTransferLiveState: Parameters<
+    typeof createBncrFileInboundHandlers
+  >[0]['refreshAcceptedFileTransferLiveState'];
+  logWarn: Parameters<typeof createBncrFileInboundHandlers>[0]['logWarn'];
+  fileRecvTransfers: Parameters<typeof createBncrFileInboundHandlers>[0]['fileRecvTransfers'];
+  inboundFileTransferMaxBytes: number;
+  inboundFileTransferMaxChunks: number;
+}) {
+  return createBncrFileInboundHandlers({
+    asString: runtime.asString,
+    now: runtime.now,
+    normalizeAccountId: runtime.normalizeAccountId,
+    finiteNonNegativeNumberOrNull: runtime.finiteNonNegativeNumberOrNull,
+    shouldIgnoreStaleEvent: runtime.shouldIgnoreStaleEvent,
+    observeLease: runtime.observeLease,
+    matchesTransferOwner: runtime.matchesTransferOwner,
+    refreshAcceptedFileTransferLiveState: runtime.refreshAcceptedFileTransferLiveState,
+    logWarn: runtime.logWarn,
+    parseRouteLike,
+    normalizeStoredSessionKey,
+    saveInboundMediaBuffer: async ({ buffer, mimeType, fileName }) =>
+      await saveOpenClawChannelMediaBuffer(
+        runtime.getApi(),
+        buffer,
+        mimeType,
+        'inbound',
+        50 * 1024 * 1024,
+        fileName,
+      ),
+    fileRecvTransfers: runtime.fileRecvTransfers,
+    inboundFileTransferMaxBytes: runtime.inboundFileTransferMaxBytes,
+    inboundFileTransferMaxChunks: runtime.inboundFileTransferMaxChunks,
+  });
+}
+
+export function createBncrInboundHandlersComponent(runtime: {
+  getApi: () => OpenClawPluginApi;
+  channelId: string;
+  bridgeId: string;
+  pluginRoot: string;
+  asString: (value: unknown, fallback?: string) => string;
+  now: () => number;
+  syncDebugFlag: () => Promise<void>;
+  shouldIgnoreStaleEvent: Parameters<typeof createBncrInboundHandlers>[0]['shouldIgnoreStaleEvent'];
+  buildInboundResponsePayload: Parameters<
+    typeof createBncrInboundHandlers
+  >[0]['buildInboundResponsePayload'];
+  refreshLiveConnectionState: Parameters<
+    typeof createBncrInboundHandlers
+  >[0]['refreshLiveConnectionState'];
+  logInfo: Parameters<typeof createBncrInboundHandlers>[0]['logInfo'];
+  logError: Parameters<typeof createBncrInboundHandlers>[0]['logError'];
+  buildInboundAcceptedLifecycleDebugInfo: Parameters<
+    typeof createBncrInboundHandlers
+  >[0]['buildInboundAcceptedLifecycleDebugInfo'];
+  isOnline: (accountId: string) => boolean;
+  hasRecentInboundReachability: (accountId: string) => boolean;
+  getActiveConnectionKey: (accountId: string) => string | null;
+  buildActiveConnectionDebugList: Parameters<
+    typeof createBncrInboundHandlers
+  >[0]['buildActiveConnectionDebugList'];
+  markLastInboundAt: (accountId: string) => void;
+  ensureCanonicalAgentId: Parameters<typeof createBncrInboundHandlers>[0]['ensureCanonicalAgentId'];
+  prepareInboundAcceptance: Parameters<
+    typeof createBncrInboundHandlers
+  >[0]['prepareInboundAcceptance'];
+  logInboundSummary: Parameters<typeof createBncrInboundHandlers>[0]['logInboundSummary'];
+  flushPushQueueBestEffort: (args: {
+    accountId?: string;
+    trigger?: string;
+    reason?: string;
+  }) => void;
+  rememberSessionRoute: (sessionKey: string, accountId: string, route: BncrRoute) => void;
+  enqueueFromReply: (args: {
+    accountId: string;
+    sessionKey: string;
+    route: BncrRoute;
+    payload: ReplyPayloadInput;
+    mediaLocalRoots?: readonly string[];
+  }) => Promise<void>;
+  setInboundActivity: (accountId: string, at: number) => void;
+  scheduleSave: () => void;
+}) {
+  return createBncrInboundHandlers({
+    channelId: runtime.channelId,
+    bridgeId: runtime.bridgeId,
+    asString: runtime.asString,
+    now: runtime.now,
+    syncDebugFlag: runtime.syncDebugFlag,
+    parseInboundParams: (params: unknown) =>
+      parseBncrInboundParams(params as BncrInboundParamsInput),
+    shouldIgnoreStaleEvent: runtime.shouldIgnoreStaleEvent,
+    buildInboundResponsePayload: runtime.buildInboundResponsePayload,
+    refreshLiveConnectionState: runtime.refreshLiveConnectionState,
+    logInfo: runtime.logInfo,
+    logError: runtime.logError,
+    buildInboundAcceptedLifecycleDebugInfo: runtime.buildInboundAcceptedLifecycleDebugInfo,
+    isOnline: runtime.isOnline,
+    hasRecentInboundReachability: runtime.hasRecentInboundReachability,
+    getActiveConnectionKey: runtime.getActiveConnectionKey,
+    buildActiveConnectionDebugList: runtime.buildActiveConnectionDebugList,
+    markLastInboundAt: runtime.markLastInboundAt,
+    getConfig: () => getOpenClawRuntimeConfig(runtime.getApi()),
+    ensureCanonicalAgentId: runtime.ensureCanonicalAgentId,
+    prepareInboundAcceptance: runtime.prepareInboundAcceptance,
+    formatDisplayScope,
+    logInboundSummary: runtime.logInboundSummary,
+    flushOnInboundAccepted: (accountId) =>
+      runtime.flushPushQueueBestEffort({
+        accountId,
+        trigger: OUTBOUND_FLUSH_TRIGGER.INBOUND,
+        reason: OUTBOUND_FLUSH_REASON.INBOUND_ACCEPTED,
+      }),
+    dispatchInbound: ({ cfg, parsed, canonicalAgentId }) =>
+      dispatchBncrInbound({
+        api: runtime.getApi(),
+        channelId: runtime.channelId,
+        cfg,
+        parsed,
+        canonicalAgentId,
+        rememberSessionRoute: runtime.rememberSessionRoute,
+        enqueueFromReply: runtime.enqueueFromReply,
+        setInboundActivity: runtime.setInboundActivity,
+        scheduleSave: runtime.scheduleSave,
+        logger: {
+          warn: (msg: string) => emitBncrLogLine('warn', msg),
+          error: (msg: string) => emitBncrLogLine('error', msg),
+        },
+      }),
+  });
+}
+
+export function createBncrChannelSendRuntimeComponent(
+  runtime: Parameters<typeof createBncrChannelSendRuntime>[0],
+) {
+  return createBncrChannelSendRuntime(runtime);
+}
+
+export function resolveBncrChannelRoot(pluginRoot: string) {
+  return pluginRoot || path.join(process.cwd(), 'plugins', 'bncr');
+}

package/src/plugin/channel-inbound-helpers.ts

@@ -0,0 +1,149 @@
+import { CHANNEL_ID } from '../core/accounts.ts';
+import { normalizeInboundSessionKey, withTaskSessionKey } from '../core/targets.ts';
+import type { BncrRoute } from '../core/types.ts';
+import type { OpenClawResolvedAgentRoute } from '../openclaw/routing-runtime.ts';
+import type { BncrChannelConfigRoot } from './channel-runtime-types.ts';
+
+function assertResolvedSessionKey(
+  resolvedRoute: OpenClawResolvedAgentRoute,
+): OpenClawResolvedAgentRoute & { sessionKey: string } {
+  if (typeof resolvedRoute.sessionKey !== 'string' || !resolvedRoute.sessionKey.trim()) {
+    throw new Error('OpenClaw resolveAgentRoute returned empty sessionKey');
+  }
+  return { ...resolvedRoute, sessionKey: resolvedRoute.sessionKey };
+}
+
+export function buildInboundAcceptedLifecycleDebugInfo(args: {
+  stage: 'accepted';
+  bridge: string;
+  accountId: string;
+  connId: string;
+  clientId?: string;
+  outboundReady: boolean;
+  preferredForOutbound: boolean;
+  inboundOnly: boolean;
+  onlineAfterSeen: boolean;
+  recentInboundReachable: boolean;
+  activeConnectionKey: string | null;
+  activeConnections: Array<{
+    connId: string;
+    clientId?: string;
+    connectedAt: number;
+    lastSeenAt: number;
+  }>;
+}) {
+  return {
+    stage: args.stage,
+    bridge: args.bridge,
+    accountId: args.accountId,
+    connId: args.connId,
+    clientId: args.clientId,
+    outboundReady: args.outboundReady,
+    preferredForOutbound: args.preferredForOutbound,
+    inboundOnly: args.inboundOnly,
+    onlineAfterSeen: args.onlineAfterSeen,
+    recentInboundReachable: args.recentInboundReachable,
+    activeConnectionKey: args.activeConnectionKey,
+    activeConnections: args.activeConnections,
+  };
+}
+
+export function resolveInboundSessionContext(args: {
+  cfg: BncrChannelConfigRoot;
+  accountId: string;
+  peer: { kind: string } & Record<string, unknown>;
+  route: BncrRoute;
+  sessionKeyFromRoute?: string;
+  canonicalAgentId: string;
+  taskKey?: string;
+  text: string;
+  extractedText?: string;
+  asString: (value: unknown, fallback?: string) => string;
+  resolveAgentRoute: (params: {
+    cfg: BncrChannelConfigRoot;
+    channel: string;
+    accountId: string;
+    peer: unknown;
+  }) => OpenClawResolvedAgentRoute;
+}) {
+  const resolvedRoute = assertResolvedSessionKey(
+    args.resolveAgentRoute({
+      cfg: args.cfg,
+      channel: CHANNEL_ID,
+      accountId: args.accountId,
+      peer: args.peer,
+    }),
+  );
+  const baseSessionKey =
+    normalizeInboundSessionKey(
+      args.sessionKeyFromRoute || '',
+      args.route,
+      args.canonicalAgentId || '',
+    ) || resolvedRoute.sessionKey;
+  const taskSessionKey = withTaskSessionKey(baseSessionKey, args.taskKey);
+  return {
+    resolvedRoute,
+    baseSessionKey,
+    taskSessionKey,
+    sessionKey: taskSessionKey || baseSessionKey,
+    inboundText: args.asString(args.extractedText || args.text || ''),
+  };
+}
+
+export function buildInboundResponsePayload(
+  args:
+    | { kind: 'stale-ignored'; accountId: string; msgId?: string | null }
+    | { kind: 'invalid-peer' }
+    | { kind: 'duplicated'; accountId: string; msgId?: string | null }
+    | { kind: 'gate-denied'; accountId: string; msgId?: string | null; reason: string }
+    | {
+        kind: 'accepted';
+        accountId: string;
+        sessionKey: string;
+        msgId?: string | null;
+        taskKey?: string | null;
+      }
+    | { kind: 'invalid-session'; accountId: string; msgId?: string | null },
+) {
+  switch (args.kind) {
+    case 'stale-ignored':
+      return {
+        accepted: false,
+        stale: true,
+        ignored: true,
+        accountId: args.accountId,
+        msgId: args.msgId ?? null,
+      };
+    case 'invalid-peer':
+      return { error: 'platform/groupId/userId required' };
+    case 'duplicated':
+      return {
+        accepted: true,
+        duplicated: true,
+        accountId: args.accountId,
+        msgId: args.msgId ?? null,
+      };
+    case 'gate-denied':
+      return {
+        accepted: false,
+        accountId: args.accountId,
+        msgId: args.msgId ?? null,
+        reason: args.reason,
+      };
+    case 'accepted':
+      return {
+        accepted: true,
+        accountId: args.accountId,
+        sessionKey: args.sessionKey,
+        msgId: args.msgId ?? null,
+        taskKey: args.taskKey ?? null,
+      };
+    case 'invalid-session':
+      return {
+        accepted: false,
+        accountId: args.accountId,
+        invalidSession: true,
+        msgId: args.msgId ?? null,
+      };
+  }
+}

package/src/plugin/channel-plugin-bridge-group.ts

@@ -0,0 +1,129 @@
+import type { ChannelMessageSendResult } from 'openclaw/plugin-sdk/channel-message';
+import type { BncrRoute } from '../core/types.ts';
+import type { ReplyPayloadInput } from '../messaging/outbound/reply-enqueue.ts';
+import type { OutboundReplyTargetPolicy } from '../messaging/outbound/reply-target-policy.ts';
+import type {
+  BncrChannelConfigRoot,
+  BncrChannelSendContext,
+  BncrStatusRuntimeSnapshot,
+  BncrVerifiedTarget,
+} from './channel-runtime-types.ts';
+import type { BncrOutboundBridge } from './outbound.ts';
+
+export type BncrChannelPluginBridge = {
+  channelMessageSendText: (
+    ctx: BncrChannelSendContext,
+  ) => ChannelMessageSendResult | Promise<ChannelMessageSendResult>;
+  channelMessageSendMedia: (
+    ctx: BncrChannelSendContext,
+  ) => ChannelMessageSendResult | Promise<ChannelMessageSendResult>;
+  channelMessageSendPayload: (
+    ctx: BncrChannelSendContext,
+  ) => ChannelMessageSendResult | Promise<ChannelMessageSendResult>;
+  channelSendText: BncrOutboundBridge['channelSendText'];
+  channelSendMedia: BncrOutboundBridge['channelSendMedia'];
+  ensureCanonicalAgentId: (args: {
+    cfg: BncrChannelConfigRoot;
+    accountId: string;
+    channelId: string;
+    peer: { kind: 'direct'; id: string };
+  }) => string;
+  resolveRouteBySession: (raw: string, accountId: string) => BncrRoute | null;
+  getChannelSummary: (defaultAccountId: string) => Record<string, unknown>;
+  getAccountRuntimeSnapshot: (accountId: string) => BncrStatusRuntimeSnapshot;
+  getStatusHeadline: (accountId: string) => string;
+  resolveVerifiedTarget: (to: string, accountId: string) => BncrVerifiedTarget;
+  rememberSessionRoute: (sessionKey: string, accountId: string, route: BncrRoute) => void;
+  enqueueFromReply: (args: {
+    accountId: string;
+    sessionKey: string;
+    route: BncrRoute;
+    payload: ReplyPayloadInput;
+    mediaLocalRoots?: readonly string[];
+    replyTargetPolicy?: OutboundReplyTargetPolicy;
+  }) => Promise<void>;
+  channelStartAccount: (ctx: unknown) => void | Promise<void>;
+  channelStopAccount: (ctx: unknown) => void | Promise<void>;
+};
+
+export function createBncrChannelPluginBridgeGroup(runtime: {
+  channelId: string;
+  defaultAccountId: string;
+  getBridge: () => BncrChannelPluginBridge;
+}) {
+  const getMessageSendBridge = () => {
+    const bridge = runtime.getBridge();
+    return {
+      channelMessageSendText: (ctx: BncrChannelSendContext) => bridge.channelMessageSendText(ctx),
+      channelMessageSendMedia: (ctx: BncrChannelSendContext) => bridge.channelMessageSendMedia(ctx),
+      channelMessageSendPayload: (ctx: BncrChannelSendContext) =>
+        bridge.channelMessageSendPayload(ctx),
+    };
+  };
+
+  const getOutboundBridge = () => {
+    const bridge = runtime.getBridge();
+    return {
+      channelSendText: (ctx: Parameters<BncrOutboundBridge['channelSendText']>[0]) =>
+        bridge.channelSendText(ctx),
+      channelSendMedia: (ctx: Parameters<BncrOutboundBridge['channelSendMedia']>[0]) =>
+        bridge.channelSendMedia(ctx),
+    };
+  };
+
+  const getMessagingBridge = () => {
+    const bridge = runtime.getBridge();
+    return {
+      canonicalAgentId: undefined,
+      ensureCanonicalAgentId: (params: { cfg: BncrChannelConfigRoot; accountId: string }) =>
+        bridge.ensureCanonicalAgentId({
+          cfg: params.cfg,
+          accountId: params.accountId,
+          channelId: runtime.channelId,
+          peer: { kind: 'direct', id: params.accountId },
+        }),
+      resolveRouteBySession: (raw: string, accountId: string) =>
+        bridge.resolveRouteBySession(raw, accountId),
+    };
+  };
+
+  const getStatusBridge = () => {
+    const bridge = runtime.getBridge();
+    return {
+      getChannelSummary: (defaultAccountId: string) => bridge.getChannelSummary(defaultAccountId),
+      getAccountRuntimeSnapshot: (accountId?: string) =>
+        bridge.getAccountRuntimeSnapshot(accountId || runtime.defaultAccountId),
+      getStatusHeadline: (accountId?: string) =>
+        bridge.getStatusHeadline(accountId || runtime.defaultAccountId),
+    };
+  };
+
+  const getToolActionBridge = () => {
+    const bridge = runtime.getBridge();
+    return {
+      resolveVerifiedTarget: (to: string, accountId: string) =>
+        bridge.resolveVerifiedTarget(to, accountId),
+      rememberSessionRoute: (sessionKey: string, accountId: string, route: BncrRoute) =>
+        bridge.rememberSessionRoute(sessionKey, accountId, route),
+      enqueueFromReply: (args: Parameters<BncrChannelPluginBridge['enqueueFromReply']>[0]) =>
+        bridge.enqueueFromReply(args),
+    };
+  };
+
+  const getGatewayBridge = () => {
+    const bridge = runtime.getBridge();
+    return {
+      channelStartAccount: (ctx: unknown) => bridge.channelStartAccount(ctx),
+      channelStopAccount: (ctx: unknown) => bridge.channelStopAccount(ctx),
+    };
+  };
+
+  return {
+    getMessageSendBridge,
+    getOutboundBridge,
+    getMessagingBridge,
+    getStatusBridge,
+    getToolActionBridge,
+    getGatewayBridge,
+  };
+}