@xmoxmo/bncr 0.1.2 → 0.1.3

package/src/core/accounts.ts

@@ -17,7 +17,13 @@ export function normalizeAccountId(accountId?: string | null): string {
 
 export function resolveDefaultDisplayName(rawName: unknown, accountId: string): string {
   const raw = asString(rawName || '').trim();
-  if (!raw || raw === accountId || /^bncr$/i.test(raw) || /^status$/i.test(raw) || /^runtime$/i.test(raw)) {
+  if (
+    !raw ||
+    raw === accountId ||
+    /^bncr$/i.test(raw) ||
+    /^status$/i.test(raw) ||
+    /^runtime$/i.test(raw)
+  ) {
     return 'Monitor';
   }
   return raw;

package/src/core/permissions.ts

@@ -7,7 +7,9 @@ function asString(v: unknown, fallback = ''): string {
 export function getBncrElevatedConfig(rootCfg: any) {
   const elevated = rootCfg?.tools?.elevated || {};
   const allowFrom = elevated?.allowFrom || {};
-  const bncrRules = Array.isArray(allowFrom?.bncr) ? allowFrom.bncr.map((x: unknown) => asString(x).trim()).filter(Boolean) : [];
+  const bncrRules = Array.isArray(allowFrom?.bncr)
+    ? allowFrom.bncr.map((x: unknown) => asString(x).trim()).filter(Boolean)
+    : [];
 
   return {
     enabled: elevated?.enabled === true,

package/src/core/probe.ts

@@ -24,7 +24,8 @@ export function probeBncrAccount(params: {
 
   let level: 'ok' | 'warn' | 'error' = 'ok';
   if (issues.length > 0) level = 'warn';
-  if (!params.connected && (params.deadLetter > 0 || params.invalidOutboxSessionKeys > 0)) level = 'error';
+  if (!params.connected && (params.deadLetter > 0 || params.invalidOutboxSessionKeys > 0))
+    level = 'error';
 
   return {
     ok: level === 'ok',

package/src/core/status.ts

@@ -49,7 +49,9 @@ export function buildIntegratedDiagnostics(input: RuntimeStatusInput): BncrDiagn
     health: {
       connected: input.connected,
       pending: input.pending,
-      pendingAdmissions: Array.isArray(input.pendingAdmissions) ? input.pendingAdmissions.length : 0,
+      pendingAdmissions: Array.isArray(input.pendingAdmissions)
+        ? input.pendingAdmissions.length
+        : 0,
       deadLetter: input.deadLetter,
       activeConnections: input.activeConnections,
       connectEvents: input.connectEvents,
@@ -94,11 +96,15 @@ export function buildStatusMetaFromRuntime(input: RuntimeStatusInput) {
   const diagnostics = buildIntegratedDiagnostics(input);
   return {
     pending: input.pending,
-    pendingAdmissionsCount: Array.isArray(input.pendingAdmissions) ? input.pendingAdmissions.length : 0,
+    pendingAdmissionsCount: Array.isArray(input.pendingAdmissions)
+      ? input.pendingAdmissions.length
+      : 0,
     pendingAdmissions: Array.isArray(input.pendingAdmissions)
       ? input.pendingAdmissions.map((item) => ({
           clientId: item.clientId,
-          scope: item.route ? `${item.route.platform}:${item.route.groupId}:${item.route.userId}` : null,
+          scope: item.route
+            ? `${item.route.platform}:${item.route.groupId}:${item.route.userId}`
+            : null,
           scopes: Array.isArray(item.routes)
             ? item.routes.map((route) => `${route.platform}:${route.groupId}:${route.userId}`)
             : [],

package/src/core/targets.ts

@@ -1,6 +1,6 @@
 import type { BncrRoute } from './types.ts';
 
-const BNCR_SESSION_KEY_PREFIX = 'agent:main:bncr:direct:';
+export type BncrSessionKind = 'direct' | 'group';
 
 function asString(v: unknown, fallback = ''): string {
   if (typeof v === 'string') return v;
@@ -84,31 +84,76 @@ export function parseRouteLike(input: unknown): BncrRoute | null {
   return { platform, groupId, userId };
 }
 
-export function parseLegacySessionKeyToStrict(input: string): string | null {
+export function resolveCanonicalSessionKind(_input?: {
+  route?: BncrRoute | null;
+  scope?: string | null;
+  sessionKey?: string | null;
+}): BncrSessionKind {
+  return 'direct';
+}
+
+export function buildCanonicalBncrSessionKey(route: BncrRoute, canonicalAgentId: string): string {
+  const agentId = asString(canonicalAgentId).trim() || 'main';
+  const kind = resolveCanonicalSessionKind({ route });
+  return `agent:${agentId}:bncr:${kind}:${routeScopeToHex(route)}`;
+}
+
+export function parseLegacySessionKey(input: string): {
+  route: BncrRoute;
+  inputKind: BncrSessionKind;
+  inputAgentId?: string;
+  source: 'legacy-direct' | 'legacy-bncr' | 'legacy-agent' | 'hex';
+} | null {
   const raw = asString(input).trim();
   if (!raw) return null;
 
-  const directLegacy = raw.match(/^agent:main:bncr:direct:([0-9a-fA-F]+):0$/);
-  if (directLegacy?.[1]) {
-    const route = parseRouteFromHexScope(directLegacy[1].toLowerCase());
-    if (route) return buildFallbackSessionKey(route);
+  const directLegacy = raw.match(/^agent:([^:]+):bncr:direct:([0-9a-fA-F]+):0$/);
+  if (directLegacy?.[1] && directLegacy?.[2]) {
+    const route = parseRouteFromHexScope(directLegacy[2].toLowerCase());
+    if (route) {
+      return {
+        route,
+        inputKind: 'direct',
+        inputAgentId: directLegacy[1],
+        source: 'legacy-direct',
+      };
+    }
   }
 
   const bncrLegacy = raw.match(/^bncr:([0-9a-fA-F]+):0$/);
   if (bncrLegacy?.[1]) {
     const route = parseRouteFromHexScope(bncrLegacy[1].toLowerCase());
-    if (route) return buildFallbackSessionKey(route);
+    if (route) {
+      return {
+        route,
+        inputKind: 'direct',
+        source: 'legacy-bncr',
+      };
+    }
   }
 
-  const agentLegacy = raw.match(/^agent:main:bncr:([0-9a-fA-F]+):0$/);
-  if (agentLegacy?.[1]) {
-    const route = parseRouteFromHexScope(agentLegacy[1].toLowerCase());
-    if (route) return buildFallbackSessionKey(route);
+  const agentLegacy = raw.match(/^agent:([^:]+):bncr:([0-9a-fA-F]+):0$/);
+  if (agentLegacy?.[1] && agentLegacy?.[2]) {
+    const route = parseRouteFromHexScope(agentLegacy[2].toLowerCase());
+    if (route) {
+      return {
+        route,
+        inputKind: 'direct',
+        inputAgentId: agentLegacy[1],
+        source: 'legacy-agent',
+      };
+    }
   }
 
   if (isLowerHex(raw.toLowerCase())) {
     const route = parseRouteFromHexScope(raw.toLowerCase());
-    if (route) return buildFallbackSessionKey(route);
+    if (route) {
+      return {
+        route,
+        inputKind: 'direct',
+        source: 'hex',
+      };
+    }
   }
 
   return null;
@@ -124,20 +169,28 @@ export function isLegacyNoiseRoute(route: BncrRoute): boolean {
   return false;
 }
 
-export function parseStrictBncrSessionKey(input: string): { sessionKey: string; scopeHex: string; route: BncrRoute } | null {
+export function parseStrictBncrSessionKey(input: string): {
+  inputSessionKey: string;
+  inputAgentId: string;
+  inputKind: BncrSessionKind;
+  scopeHex: string;
+  route: BncrRoute;
+} | null {
   const raw = asString(input).trim();
   if (!raw) return null;
 
-  const m = raw.match(/^agent:main:bncr:(direct|group):(.+)$/);
-  if (!m?.[1] || !m?.[2]) return null;
+  const m = raw.match(/^agent:([^:]+):bncr:(direct|group):(.+)$/);
+  if (!m?.[1] || !m?.[2] || !m?.[3]) return null;
 
-  const payload = asString(m[2]).trim();
+  const inputAgentId = asString(m[1]).trim();
+  const inputKind = m[2] as BncrSessionKind;
+  const payload = asString(m[3]).trim();
   let route: BncrRoute | null = null;
   let scopeHex = '';
 
   if (isLowerHex(payload)) {
-    scopeHex = payload;
-    route = parseRouteFromHexScope(payload);
+    scopeHex = payload.toLowerCase();
+    route = parseRouteFromHexScope(scopeHex);
   } else {
     route = parseRouteFromScope(payload);
     if (route) scopeHex = routeScopeToHex(route);
@@ -146,7 +199,9 @@ export function parseStrictBncrSessionKey(input: string): { sessionKey: string;
   if (!route || !scopeHex) return null;
 
   return {
-    sessionKey: `${BNCR_SESSION_KEY_PREFIX}${scopeHex}`,
+    inputSessionKey: raw,
+    inputAgentId,
+    inputKind,
     scopeHex,
     route,
   };
@@ -155,11 +210,17 @@ export function parseStrictBncrSessionKey(input: string): { sessionKey: string;
 export function normalizeTaskKey(input: unknown): string | null {
   const raw = asString(input).trim().toLowerCase();
   if (!raw) return null;
-  const normalized = raw.replace(/[^a-z0-9_-]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 32);
+  const normalized = raw
+    .replace(/[^a-z0-9_-]+/g, '-')
+    .replace(/^-+|-+$/g, '')
+    .slice(0, 32);
   return normalized || null;
 }
 
-export function normalizeStoredSessionKey(input: string): { sessionKey: string; route: BncrRoute } | null {
+export function normalizeStoredSessionKey(
+  input: string,
+  canonicalAgentId?: string | null,
+): { sessionKey: string; route: BncrRoute } | null {
   const raw = asString(input).trim();
   if (!raw) return null;
 
@@ -172,42 +233,91 @@ export function normalizeStoredSessionKey(input: string): { sessionKey: string;
     taskKey = normalizeTaskKey(taskTagged[2]);
   }
 
+  let route: BncrRoute | null = null;
+  let passthroughAgentId: string | null = null;
+
   const strict = parseStrictBncrSessionKey(base);
   if (strict) {
-    if (isLegacyNoiseRoute(strict.route)) return null;
-    return {
-      sessionKey: taskKey ? `${strict.sessionKey}:task:${taskKey}` : strict.sessionKey,
-      route: strict.route,
-    };
+    route = strict.route;
+    passthroughAgentId = strict.inputAgentId;
+  }
+
+  if (!route) {
+    const legacy = parseLegacySessionKey(base);
+    if (legacy) {
+      route = legacy.route;
+      passthroughAgentId = legacy.inputAgentId || null;
+    }
   }
 
-  const migrated = parseLegacySessionKeyToStrict(base);
-  if (!migrated) return null;
+  if (!route) return null;
+  if (isLegacyNoiseRoute(route)) return null;
 
-  const parsed = parseStrictBncrSessionKey(migrated);
-  if (!parsed) return null;
-  if (isLegacyNoiseRoute(parsed.route)) return null;
+  const finalAgentId = asString(canonicalAgentId).trim() || passthroughAgentId;
+  if (!finalAgentId) return null;
 
+  const finalSessionKey = buildCanonicalBncrSessionKey(route, finalAgentId);
   return {
-    sessionKey: taskKey ? `${parsed.sessionKey}:task:${taskKey}` : parsed.sessionKey,
-    route: parsed.route,
+    sessionKey: taskKey ? `${finalSessionKey}:task:${taskKey}` : finalSessionKey,
+    route,
   };
 }
 
-export function normalizeInboundSessionKey(scope: string, route: BncrRoute): string | null {
+export function normalizeInboundSessionKey(
+  scope: string,
+  route: BncrRoute,
+  canonicalAgentId: string,
+): string | null {
   const raw = asString(scope).trim();
-  if (!raw) return buildFallbackSessionKey(route);
+  let finalRoute: BncrRoute | null = null;
+
+  if (!raw) {
+    finalRoute = route;
+  }
+
+  if (!finalRoute) {
+    const strict = parseStrictBncrSessionKey(raw);
+    if (strict?.route) {
+      finalRoute = strict.route;
+    }
+  }
+
+  if (!finalRoute) {
+    const legacy = parseLegacySessionKey(raw);
+    if (legacy?.route) {
+      finalRoute = legacy.route;
+    }
+  }
+
+  if (!finalRoute) {
+    const displayRoute = parseRouteFromDisplayScope(raw);
+    if (displayRoute) {
+      finalRoute = displayRoute;
+    }
+  }
+
+  if (!finalRoute) {
+    const scopedRoute = parseRouteFromScope(raw);
+    if (scopedRoute) {
+      finalRoute = scopedRoute;
+    }
+  }
+
+  if (!finalRoute && route) {
+    finalRoute = route;
+  }
 
-  const parsed = parseStrictBncrSessionKey(raw);
-  if (!parsed) return null;
-  return parsed.sessionKey;
+  if (!finalRoute) return null;
+  return buildCanonicalBncrSessionKey(finalRoute, canonicalAgentId);
 }
 
 export function extractInlineTaskKey(text: string): { taskKey: string | null; text: string } {
   const raw = asString(text);
   if (!raw) return { taskKey: null, text: '' };
 
-  const tagged = raw.match(/^\s*(?:#task|\/task)\s*[:=]\s*([a-zA-Z0-9_-]{1,32})\s*\n?\s*([\s\S]*)$/i);
+  const tagged = raw.match(
+    /^\s*(?:#task|\/task)\s*[:=]\s*([a-zA-Z0-9_-]{1,32})\s*\n?\s*([\s\S]*)$/i,
+  );
   if (tagged) {
     return {
       taskKey: normalizeTaskKey(tagged[1]),
@@ -234,8 +344,8 @@ export function withTaskSessionKey(sessionKey: string, taskKey?: string | null):
   return `${base}:task:${tk}`;
 }
 
-export function buildFallbackSessionKey(route: BncrRoute): string {
-  return `${BNCR_SESSION_KEY_PREFIX}${routeScopeToHex(route)}`;
+export function buildFallbackSessionKey(route: BncrRoute, canonicalAgentId: string): string {
+  return buildCanonicalBncrSessionKey(route, canonicalAgentId);
 }
 
 export function routeKey(accountId: string, route: BncrRoute): string {

package/src/messaging/inbound/commands.ts

@@ -1,4 +1,8 @@
-import { formatDisplayScope, normalizeInboundSessionKey, withTaskSessionKey } from '../../core/targets.ts';
+import {
+  formatDisplayScope,
+  normalizeInboundSessionKey,
+  withTaskSessionKey,
+} from '../../core/targets.ts';
 
 type ParsedInbound = ReturnType<typeof import('./parse.ts')['parseBncrInboundParams']>;
 
@@ -14,13 +18,13 @@ export function parseBncrNativeCommand(text: string): NativeCommand | null {
   const match = raw.match(/^\/([^\s]+)(?:\s+([\s\S]*))?$/i);
   if (!match) return null;
 
-  const command = String(match[1] || '').trim().toLowerCase();
+  const command = String(match[1] || '')
+    .trim()
+    .toLowerCase();
   if (!command) return null;
 
   const rest = String(match[2] || '').trim();
-  const body = command === 'help'
-    ? ['/commands', rest].filter(Boolean).join(' ')
-    : raw;
+  const body = command === 'help' ? ['/commands', rest].filter(Boolean).join(' ') : raw;
   return { command, raw, body };
 }
 
@@ -29,6 +33,7 @@ export async function handleBncrNativeCommand(params: {
   channelId: string;
   cfg: any;
   parsed: ParsedInbound;
+  canonicalAgentId: string;
   rememberSessionRoute: (sessionKey: string, accountId: string, route: any) => void;
   enqueueFromReply: (args: {
     accountId: string;
@@ -39,7 +44,16 @@ export async function handleBncrNativeCommand(params: {
   }) => Promise<void>;
   logger?: { warn?: (msg: string) => void; error?: (msg: string) => void };
 }): Promise<{ handled: false } | { handled: true; command: string; sessionKey: string }> {
-  const { api, channelId, cfg, parsed, rememberSessionRoute, enqueueFromReply, logger } = params;
+  const {
+    api,
+    channelId,
+    cfg,
+    parsed,
+    canonicalAgentId,
+    rememberSessionRoute,
+    enqueueFromReply,
+    logger,
+  } = params;
   const { accountId, route, peer, sessionKeyfromroute, clientId, extracted, msgId } = parsed;
   const command = parseBncrNativeCommand(extracted.text);
   if (!command) return { handled: false };
@@ -51,11 +65,14 @@ export async function handleBncrNativeCommand(params: {
     peer,
   });
 
-  const baseSessionKey = normalizeInboundSessionKey(sessionKeyfromroute, route) || resolvedRoute.sessionKey;
+  const baseSessionKey =
+    normalizeInboundSessionKey(sessionKeyfromroute, route, canonicalAgentId) ||
+    resolvedRoute.sessionKey;
   const taskSessionKey = withTaskSessionKey(baseSessionKey, extracted.taskKey);
   const sessionKey = taskSessionKey || baseSessionKey;
   rememberSessionRoute(baseSessionKey, accountId, route);
-  if (taskSessionKey && taskSessionKey !== baseSessionKey) rememberSessionRoute(taskSessionKey, accountId, route);
+  if (taskSessionKey && taskSessionKey !== baseSessionKey)
+    rememberSessionRoute(taskSessionKey, accountId, route);
 
   const displayTo = formatDisplayScope(route);
   const body = command.body;
@@ -113,10 +130,17 @@ export async function handleBncrNativeCommand(params: {
       disableBlockStreaming: true,
     },
     dispatcherOptions: {
-      deliver: async (payload: { text?: string; mediaUrl?: string; mediaUrls?: string[]; audioAsVoice?: boolean }, info?: { kind?: 'tool' | 'block' | 'final' }) => {
+      deliver: async (
+        payload: { text?: string; mediaUrl?: string; mediaUrls?: string[]; audioAsVoice?: boolean },
+        info?: { kind?: 'tool' | 'block' | 'final' },
+      ) => {
         const kind = info?.kind;
         if (kind && kind !== 'final') return;
-        const hasPayload = Boolean(payload?.text || payload?.mediaUrl || (Array.isArray(payload?.mediaUrls) && payload.mediaUrls.length > 0));
+        const hasPayload = Boolean(
+          payload?.text ||
+            payload?.mediaUrl ||
+            (Array.isArray(payload?.mediaUrls) && payload.mediaUrls.length > 0),
+        );
         if (!hasPayload) return;
         responded = true;
         await enqueueFromReply({

package/src/messaging/inbound/dispatch.ts

@@ -1,5 +1,9 @@
 import fs from 'node:fs';
-import { formatDisplayScope, normalizeInboundSessionKey, withTaskSessionKey } from '../../core/targets.ts';
+import {
+  formatDisplayScope,
+  normalizeInboundSessionKey,
+  withTaskSessionKey,
+} from '../../core/targets.ts';
 import { handleBncrNativeCommand } from './commands.ts';
 
 type ParsedInbound = ReturnType<typeof import('./parse.ts')['parseBncrInboundParams']>;
@@ -9,6 +13,7 @@ export async function dispatchBncrInbound(params: {
   channelId: string;
   cfg: any;
   parsed: ParsedInbound;
+  canonicalAgentId: string;
   rememberSessionRoute: (sessionKey: string, accountId: string, route: any) => void;
   enqueueFromReply: (args: {
     accountId: string;
@@ -21,14 +26,43 @@ export async function dispatchBncrInbound(params: {
   scheduleSave: () => void;
   logger?: { warn?: (msg: string) => void; error?: (msg: string) => void };
 }) {
-  const { api, channelId, cfg, parsed, rememberSessionRoute, enqueueFromReply, setInboundActivity, scheduleSave, logger } = params;
-  const { accountId, route, peer, sessionKeyfromroute, clientId, text, msgType, mediaBase64, mediaPathFromTransfer, mimeType, fileName, msgId, extracted, platform, groupId, userId } = parsed;
+  const {
+    api,
+    channelId,
+    cfg,
+    parsed,
+    canonicalAgentId,
+    rememberSessionRoute,
+    enqueueFromReply,
+    setInboundActivity,
+    scheduleSave,
+    logger,
+  } = params;
+  const {
+    accountId,
+    route,
+    peer,
+    sessionKeyfromroute,
+    clientId,
+    text,
+    msgType,
+    mediaBase64,
+    mediaPathFromTransfer,
+    mimeType,
+    fileName,
+    msgId,
+    extracted,
+    platform,
+    groupId,
+    userId,
+  } = parsed;
 
   const nativeCommand = await handleBncrNativeCommand({
     api,
     channelId,
     cfg,
     parsed,
+    canonicalAgentId,
     rememberSessionRoute,
     enqueueFromReply,
     logger,
@@ -52,7 +86,9 @@ export async function dispatchBncrInbound(params: {
     peer,
   });
 
-  const baseSessionKey = normalizeInboundSessionKey(sessionKeyfromroute, route) || resolvedRoute.sessionKey;
+  const baseSessionKey =
+    normalizeInboundSessionKey(sessionKeyfromroute, route, canonicalAgentId) ||
+    resolvedRoute.sessionKey;
   const agentText = extracted.text;
   const taskSessionKey = withTaskSessionKey(baseSessionKey, extracted.taskKey);
   const sessionKey = taskSessionKey || baseSessionKey;

package/src/messaging/inbound/gate.ts

@@ -2,9 +2,7 @@ import { normalizeAccountId } from '../../core/accounts.ts';
 import { resolveBncrChannelPolicy } from '../../core/policy.ts';
 import { buildDisplayScopeCandidates } from '../../core/targets.ts';
 
-export type BncrGateResult =
-  | { allowed: true }
-  | { allowed: false; reason: string };
+export type BncrGateResult = { allowed: true } | { allowed: false; reason: string };
 
 function asString(v: unknown, fallback = ''): string {
   if (typeof v === 'string') return v;

package/src/messaging/inbound/parse.ts

@@ -1,7 +1,7 @@
 import { createHash } from 'node:crypto';
 import { normalizeAccountId } from '../../core/accounts.ts';
-import type { BncrRoute } from '../../core/types.ts';
 import { extractInlineTaskKey } from '../../core/targets.ts';
+import type { BncrRoute } from '../../core/types.ts';
 
 function asString(v: unknown, fallback = ''): string {
   if (typeof v === 'string') return v;
@@ -28,7 +28,10 @@ export function inboundDedupKey(params: {
 
   const text = asString(params.text || '').trim();
   const media = asString(params.mediaBase64 || '');
-  const digest = createHash('sha1').update(`${text}\n${media.slice(0, 256)}`).digest('hex').slice(0, 16);
+  const digest = createHash('sha1')
+    .update(`${text}\n${media.slice(0, 256)}`)
+    .digest('hex')
+    .slice(0, 16);
   return `${accountId}|${platform}|${groupId}|${userId}|hash:${digest}`;
 }
 

package/src/messaging/outbound/media.ts

@@ -9,21 +9,34 @@ function isAudioMimeType(mimeType?: string): boolean {
   return mt.startsWith('audio/');
 }
 
-export function resolveBncrOutboundMessageType(params: { mimeType?: string; fileName?: string; hintedType?: string; hasPayload?: boolean }): 'text' | 'image' | 'video' | 'voice' | 'audio' | 'file' {
+export function resolveBncrOutboundMessageType(params: {
+  mimeType?: string;
+  fileName?: string;
+  hintedType?: string;
+  hasPayload?: boolean;
+}): 'text' | 'image' | 'video' | 'voice' | 'audio' | 'file' {
   const hinted = asString(params.hintedType || '').toLowerCase();
   const hasPayload = !!params.hasPayload;
   const mt = asString(params.mimeType || '').toLowerCase();
   const major = mt.split('/')[0] || '';
-  const isStandard = hinted === 'text' || hinted === 'image' || hinted === 'video' || hinted === 'voice' || hinted === 'audio' || hinted === 'file';
+  const isStandard =
+    hinted === 'text' ||
+    hinted === 'image' ||
+    hinted === 'video' ||
+    hinted === 'voice' ||
+    hinted === 'audio' ||
+    hinted === 'file';
 
   if (hasPayload && major === 'text' && (hinted === 'text' || !isStandard)) return 'file';
   if (hinted === 'voice') {
     if (isAudioMimeType(mt)) return 'voice';
-    if (major === 'text' || major === 'image' || major === 'video' || major === 'audio') return major as any;
+    if (major === 'text' || major === 'image' || major === 'video' || major === 'audio')
+      return major as any;
     return 'file';
   }
   if (isStandard) return hinted as any;
-  if (major === 'text' || major === 'image' || major === 'video' || major === 'audio') return major as any;
+  if (major === 'text' || major === 'image' || major === 'video' || major === 'audio')
+    return major as any;
   return 'file';
 }
 
@@ -31,7 +44,13 @@ export function buildBncrMediaOutboundFrame(params: {
   messageId: string;
   sessionKey: string;
   route: { platform: string; groupId: string; userId: string };
-  media: { mode: 'base64' | 'chunk'; mimeType?: string; fileName?: string; mediaBase64?: string; path?: string };
+  media: {
+    mode: 'base64' | 'chunk';
+    mimeType?: string;
+    fileName?: string;
+    mediaBase64?: string;
+    path?: string;
+  };
   mediaUrl: string;
   mediaMsg: string;
   fileName: string;

package/src/messaging/outbound/send.ts

@@ -4,7 +4,10 @@ export async function sendBncrText(params: {
   to: string;
   text: string;
   mediaLocalRoots?: readonly string[];
-  resolveVerifiedTarget: (to: string, accountId: string) => { sessionKey: string; route: any; displayScope: string };
+  resolveVerifiedTarget: (
+    to: string,
+    accountId: string,
+  ) => { sessionKey: string; route: any; displayScope: string };
   rememberSessionRoute: (sessionKey: string, accountId: string, route: any) => void;
   enqueueFromReply: (args: {
     accountId: string;
@@ -28,7 +31,11 @@ export async function sendBncrText(params: {
     mediaLocalRoots: params.mediaLocalRoots,
   });
 
-  return { channel: params.channelId, messageId: params.createMessageId(), chatId: verified.sessionKey };
+  return {
+    channel: params.channelId,
+    messageId: params.createMessageId(),
+    chatId: verified.sessionKey,
+  };
 }
 
 export async function sendBncrMedia(params: {
@@ -40,13 +47,22 @@ export async function sendBncrMedia(params: {
   asVoice?: boolean;
   audioAsVoice?: boolean;
   mediaLocalRoots?: readonly string[];
-  resolveVerifiedTarget: (to: string, accountId: string) => { sessionKey: string; route: any; displayScope: string };
+  resolveVerifiedTarget: (
+    to: string,
+    accountId: string,
+  ) => { sessionKey: string; route: any; displayScope: string };
   rememberSessionRoute: (sessionKey: string, accountId: string, route: any) => void;
   enqueueFromReply: (args: {
     accountId: string;
     sessionKey: string;
     route: any;
-    payload: { text?: string; mediaUrl?: string; mediaUrls?: string[]; asVoice?: boolean; audioAsVoice?: boolean };
+    payload: {
+      text?: string;
+      mediaUrl?: string;
+      mediaUrls?: string[];
+      asVoice?: boolean;
+      audioAsVoice?: boolean;
+    };
     mediaLocalRoots?: readonly string[];
   }) => Promise<void>;
   createMessageId: () => string;
@@ -67,5 +83,9 @@ export async function sendBncrMedia(params: {
     mediaLocalRoots: params.mediaLocalRoots,
   });
 
-  return { channel: params.channelId, messageId: params.createMessageId(), chatId: verified.sessionKey };
+  return {
+    channel: params.channelId,
+    messageId: params.createMessageId(),
+    chatId: verified.sessionKey,
+  };
 }