@xmoxmo/bncr 0.1.6 → 0.1.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmoxmo/bncr",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "private": false,
   "type": "module",
   "license": "MIT",

package/src/channel.ts

@@ -38,9 +38,11 @@ import {
 import {
   buildCanonicalBncrSessionKey,
   formatDisplayScope,
+  formatTargetDisplay,
   isLowerHex,
   normalizeInboundSessionKey,
   normalizeStoredSessionKey,
+  parseExplicitTarget,
   parseRouteFromDisplayScope,
   parseRouteFromHexScope,
   parseRouteFromScope,
@@ -65,6 +67,11 @@ import {
   resolveBncrOutboundMessageType,
 } from './messaging/outbound/media.ts';
 import { sendBncrMedia, sendBncrText } from './messaging/outbound/send.ts';
+import { resolveBncrOutboundSessionRoute } from './messaging/outbound/session-route.ts';
+import {
+  looksLikeBncrExplicitTarget,
+  resolveBncrOutboundTarget,
+} from './messaging/outbound/target-resolver.ts';
 const BRIDGE_VERSION = 2;
 const BNCR_PUSH_EVENT = 'bncr.push';
 const CONNECT_TTL_MS = 120_000;
@@ -1556,77 +1563,35 @@ class BncrBridgeRuntime {
       );
     }
 
-    const wantedRouteKey = routeKey(acc, route);
-    let best: { sessionKey: string; route: BncrRoute; updatedAt: number } | null = null;
-
-    if (BNCR_DEBUG_VERBOSE) {
-      this.api.logger.info?.(
-        `[bncr-target-incoming-route] raw=${raw} accountId=${acc} route=${JSON.stringify(route)}`,
-      );
-      this.api.logger.info?.(
-        `[bncr-target-incoming-sessionRoutes] raw=${raw} accountId=${acc} sessionRoutes=${JSON.stringify(this.sessionRoutes.entries())}`,
-      );
-    }
-
-    for (const [key, info] of this.sessionRoutes.entries()) {
-      if (normalizeAccountId(info.accountId) !== acc) continue;
-      const parsed = parseStrictBncrSessionKey(key);
-      if (!parsed) continue;
-      if (routeKey(acc, parsed.route) !== wantedRouteKey) continue;
-
-      const updatedAt = Number(info.updatedAt || 0);
-      if (!best || updatedAt >= best.updatedAt) {
-        best = {
-          sessionKey: key,
-          route: parsed.route,
-          updatedAt,
-        };
-      }
-    }
-
-    if (!best) {
-      const updatedAt = 0;
-      const canonicalAgentId =
-        this.canonicalAgentId ||
-        this.ensureCanonicalAgentId({
-          cfg: this.api.runtime.config?.get?.() || {},
-          accountId: acc,
-          channelId: CHANNEL_ID,
-          peer: { kind: 'direct', id: route.groupId === '0' ? route.userId : route.groupId },
-        });
-      best = {
-        sessionKey: buildCanonicalBncrSessionKey(route, canonicalAgentId),
-        route,
-        updatedAt,
-      };
-    }
+    const canonicalAgentId =
+      this.canonicalAgentId ||
+      this.ensureCanonicalAgentId({
+        cfg: this.api.runtime.config?.get?.() || {},
+        accountId: acc,
+        channelId: CHANNEL_ID,
+        peer: { kind: 'direct', id: route.groupId === '0' ? route.userId : route.groupId },
+      });
+    const verified = {
+      sessionKey: buildCanonicalBncrSessionKey(route, canonicalAgentId),
+      route,
+      displayScope: formatDisplayScope(route),
+    };
 
     if (BNCR_DEBUG_VERBOSE) {
       this.api.logger.info?.(
-        `[bncr-target-incoming-best] raw=${raw} accountId=${acc} best=${JSON.stringify(best)}`,
+        `[bncr-target-incoming-canonical] raw=${raw} accountId=${acc} verified=${JSON.stringify(verified)}`,
       );
     }
 
-    if (!best) {
-      this.api.logger.warn?.(
-        `[bncr-target-miss] raw=${raw} accountId=${acc} sessionRoutes=${this.sessionRoutes.size}`,
-      );
-      throw new Error(`bncr target not found in known sessions: ${raw}`);
-    }
-
     // 发送链路命中目标时，同步刷新 lastSession，避免状态页显示过期会话。
     this.lastSessionByAccount.set(acc, {
-      sessionKey: best.sessionKey,
-      scope: formatDisplayScope(best.route),
+      sessionKey: verified.sessionKey,
+      scope: verified.displayScope,
       updatedAt: now(),
     });
     this.scheduleSave();
 
-    return {
-      sessionKey: best.sessionKey,
-      route: best.route,
-      displayScope: formatDisplayScope(best.route),
-    };
+    return verified;
   }
 
   private markActivity(accountId: string, at = now()) {
@@ -3070,9 +3035,68 @@ export function createBncrChannelPlugin(bridge: BncrBridgeRuntime) {
         const input = asString(raw).trim();
         return input || undefined;
       },
+      parseExplicitTarget: ({ raw, accountId, cfg }: any) => {
+        const resolvedAccountId = normalizeAccountId(
+          asString(accountId || BNCR_DEFAULT_ACCOUNT_ID),
+        );
+        const canonicalAgentId =
+          bridge.canonicalAgentId ||
+          bridge.ensureCanonicalAgentId({ cfg, accountId: resolvedAccountId });
+        return parseExplicitTarget(asString(raw).trim(), { canonicalAgentId });
+      },
+      formatTargetDisplay: ({ target }: any) => {
+        return formatTargetDisplay(target);
+      },
+      resolveSessionTarget: ({ id, accountId, cfg }: any) => {
+        const raw = asString(id).trim();
+        if (!raw) return undefined;
+        const resolvedAccountId = normalizeAccountId(
+          asString(accountId || BNCR_DEFAULT_ACCOUNT_ID),
+        );
+        const canonicalAgentId =
+          bridge.canonicalAgentId ||
+          bridge.ensureCanonicalAgentId({ cfg, accountId: resolvedAccountId });
+
+        let parsed = parseExplicitTarget(raw, { canonicalAgentId });
+        if (!parsed) {
+          const route = bridge.resolveRouteBySession(raw, resolvedAccountId);
+          if (route) {
+            parsed = parseExplicitTarget(formatDisplayScope(route), { canonicalAgentId });
+          }
+        }
+        return parsed?.displayScope || undefined;
+      },
+      resolveOutboundSessionRoute: (params: any) => {
+        const accountId = normalizeAccountId(
+          asString(params?.accountId || BNCR_DEFAULT_ACCOUNT_ID),
+        );
+        const canonicalAgentId =
+          bridge.canonicalAgentId || bridge.ensureCanonicalAgentId({ cfg: params?.cfg, accountId });
+        return resolveBncrOutboundSessionRoute({
+          ...params,
+          canonicalAgentId,
+          resolveRouteBySession: (raw: string, acc: string) =>
+            bridge.resolveRouteBySession(raw, acc),
+        });
+      },
       targetResolver: {
         looksLikeId: (raw: string, normalized?: string) => {
-          return Boolean(asString(normalized || raw).trim());
+          return looksLikeBncrExplicitTarget(asString(normalized || raw).trim());
+        },
+        resolveTarget: async ({ accountId, input, normalized }) => {
+          const resolved = resolveBncrOutboundTarget({
+            target: asString(normalized || input).trim(),
+            accountId: normalizeAccountId(asString(accountId || BNCR_DEFAULT_ACCOUNT_ID)),
+            resolveRouteBySession: (raw: string, acc: string) =>
+              this.resolveRouteBySession(raw, acc),
+          });
+          if (!resolved) return null;
+          return {
+            to: resolved.displayScope,
+            kind: resolved.kind,
+            display: resolved.displayScope,
+            source: 'normalized' as const,
+          };
         },
         hint: 'Standard to=Bncr:<platform>:<group>:<user> or Bncr:<platform>:<user>; sessionKey keeps existing strict/legacy compatibility, canonical sessionKey=agent:<agentId>:bncr:direct:<hex>',
       },

package/src/core/targets.ts

@@ -1,6 +1,24 @@
 import type { BncrRoute } from './types.ts';
 
 export type BncrSessionKind = 'direct' | 'group';
+export type BncrExplicitTarget = {
+  raw: string;
+  normalized: string;
+  source:
+    | 'display-scope'
+    | 'strict-session-key'
+    | 'legacy-session-key'
+    | 'hex-scope'
+    | 'route-scope';
+  kind: BncrSessionKind;
+  chatType: 'direct';
+  displayScope: string;
+  route: BncrRoute;
+  canonicalSessionKey?: string;
+  platform: string;
+  userId: string;
+  groupId?: string;
+};
 
 function asString(v: unknown, fallback = ''): string {
   if (typeof v === 'string') return v;
@@ -54,6 +72,85 @@ export function buildDisplayScopeCandidates(route: BncrRoute): string[] {
   return Array.from(new Set(candidates.map((x) => asString(x).trim()).filter(Boolean)));
 }
 
+export function formatTargetDisplay(
+  input: BncrRoute | BncrExplicitTarget | null | undefined,
+): string {
+  if (!input) return '';
+  const route = parseRouteLike((input as any)?.route) || parseRouteLike(input);
+  if (!route) return '';
+  return formatDisplayScope(route);
+}
+
+export function parseExplicitTarget(
+  input: string,
+  options?: { canonicalAgentId?: string | null },
+): BncrExplicitTarget | null {
+  const raw = asString(input).trim();
+  if (!raw) return null;
+
+  const canonicalAgentId = asString(options?.canonicalAgentId).trim() || undefined;
+  let route: BncrRoute | null = null;
+  let source: BncrExplicitTarget['source'] | null = null;
+
+  const strict = parseStrictBncrSessionKey(raw);
+  if (strict?.route) {
+    route = strict.route;
+    source = 'strict-session-key';
+  }
+
+  if (!route) {
+    const displayRoute = parseRouteFromDisplayScope(raw);
+    if (displayRoute) {
+      route = displayRoute;
+      source = 'display-scope';
+    }
+  }
+
+  if (!route) {
+    const legacy = parseLegacySessionKey(raw);
+    if (legacy?.route) {
+      route = legacy.route;
+      source = legacy.source === 'hex' ? 'hex-scope' : 'legacy-session-key';
+    }
+  }
+
+  if (!route) {
+    const hexRoute = parseRouteFromHexScope(raw);
+    if (hexRoute) {
+      route = hexRoute;
+      source = 'hex-scope';
+    }
+  }
+
+  if (!route) {
+    const scopedRoute = parseRouteFromScope(raw);
+    if (scopedRoute) {
+      route = scopedRoute;
+      source = 'route-scope';
+    }
+  }
+
+  if (!route || !source) return null;
+
+  const kind: BncrSessionKind = route.groupId === '0' ? 'direct' : 'group';
+  const displayScope = formatDisplayScope(route);
+  return {
+    raw,
+    normalized: displayScope,
+    source,
+    kind,
+    chatType: 'direct',
+    displayScope,
+    route,
+    ...(canonicalAgentId
+      ? { canonicalSessionKey: buildCanonicalBncrSessionKey(route, canonicalAgentId) }
+      : {}),
+    platform: route.platform,
+    userId: route.userId,
+    ...(route.groupId === '0' ? {} : { groupId: route.groupId }),
+  };
+}
+
 export function isLowerHex(input: string): boolean {
   const raw = asString(input).trim();
   return !!raw && /^[0-9a-fA-F]+$/.test(raw) && raw.length % 2 === 0;

package/src/messaging/outbound/media.ts

@@ -55,7 +55,7 @@ export function buildBncrMediaOutboundFrame(params: {
   mediaMsg: string;
   fileName: string;
   hintedType?: string;
-  kind?: 'block' | 'final';
+  kind?: 'tool' | 'block' | 'final';
   now: number;
 }) {
   return {

package/src/messaging/outbound/session-route.ts

@@ -0,0 +1,73 @@
+import { buildChannelOutboundSessionRoute } from 'openclaw/plugin-sdk/core';
+import {
+  buildCanonicalBncrSessionKey,
+  formatDisplayScope,
+  parseRouteFromDisplayScope,
+  parseStrictBncrSessionKey,
+  routeScopeToHex,
+} from '../../core/targets.ts';
+import type { BncrRoute } from '../../core/types.ts';
+
+type ResolveBncrOutboundSessionRouteParams = {
+  cfg: any;
+  channel: string;
+  agentId: string;
+  accountId?: string;
+  target: string;
+  resolvedTarget?: { to?: string } | null;
+  threadId?: string;
+  canonicalAgentId: string;
+  resolveRouteBySession?: (raw: string, accountId: string) => BncrRoute | null;
+};
+
+function asString(v: unknown, fallback = ''): string {
+  if (typeof v === 'string') return v;
+  if (v == null) return fallback;
+  return String(v);
+}
+
+export function resolveBncrOutboundSessionRoute(params: ResolveBncrOutboundSessionRouteParams) {
+  const raw = asString(params.resolvedTarget?.to || params.target).trim();
+  if (!raw) return null;
+
+  let route: BncrRoute | null = null;
+
+  const strict = parseStrictBncrSessionKey(raw);
+  if (strict) {
+    route = strict.route;
+  } else {
+    route = parseRouteFromDisplayScope(raw);
+    if (!route && params.accountId && params.resolveRouteBySession) {
+      route = params.resolveRouteBySession(raw, params.accountId);
+    }
+  }
+
+  if (!route) return null;
+
+  const canonicalAgentId =
+    asString(params.canonicalAgentId).trim() || asString(params.agentId).trim() || 'main';
+  const peerId = routeScopeToHex(route);
+  const sessionKey = buildCanonicalBncrSessionKey(route, canonicalAgentId);
+  const displayTo = formatDisplayScope(route);
+
+  const built = buildChannelOutboundSessionRoute({
+    cfg: params.cfg,
+    agentId: canonicalAgentId,
+    channel: params.channel,
+    accountId: params.accountId,
+    peer: {
+      kind: 'direct',
+      id: peerId,
+    },
+    chatType: 'direct',
+    from: displayTo,
+    to: displayTo,
+    ...(params.threadId !== undefined ? { threadId: params.threadId } : {}),
+  });
+
+  return {
+    ...built,
+    sessionKey,
+    baseSessionKey: sessionKey,
+  };
+}

package/src/messaging/outbound/target-resolver.ts

@@ -0,0 +1,56 @@
+import {
+  formatDisplayScope,
+  parseRouteFromDisplayScope,
+  parseStrictBncrSessionKey,
+} from '../../core/targets.ts';
+import type { BncrRoute } from '../../core/types.ts';
+
+type ResolveBncrOutboundTargetParams = {
+  target: string;
+  accountId?: string | null;
+  resolveRouteBySession?: (raw: string, accountId: string) => BncrRoute | null;
+};
+
+function asString(v: unknown, fallback = ''): string {
+  if (typeof v === 'string') return v;
+  if (v == null) return fallback;
+  return String(v);
+}
+
+export function looksLikeBncrExplicitTarget(input: string): boolean {
+  const raw = asString(input).trim();
+  if (!raw) return false;
+  return Boolean(parseRouteFromDisplayScope(raw) || parseStrictBncrSessionKey(raw));
+}
+
+export function resolveBncrOutboundTarget(params: ResolveBncrOutboundTargetParams): {
+  route: BncrRoute;
+  displayScope: string;
+  kind: 'user' | 'group';
+} | null {
+  const raw = asString(params.target).trim();
+  if (!raw) return null;
+
+  let route: BncrRoute | null = null;
+
+  const strict = parseStrictBncrSessionKey(raw);
+  if (strict?.route) {
+    route = strict.route;
+  }
+
+  if (!route) {
+    route = parseRouteFromDisplayScope(raw);
+  }
+
+  if (!route && params.accountId && params.resolveRouteBySession) {
+    route = params.resolveRouteBySession(raw, params.accountId);
+  }
+
+  if (!route) return null;
+
+  return {
+    route,
+    displayScope: formatDisplayScope(route),
+    kind: route.groupId === '0' ? 'user' : 'group',
+  };
+}