@xmoxmo/bncr 0.6.8 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xmoxmo/bncr",
-  "version": "0.6.8",
+  "version": "0.7.0",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -27,6 +27,7 @@
   "scripts": {
     "build": "npx -y esbuild@0.28.0 index.ts --bundle --platform=node --format=esm --target=node22 --packages=external --outfile=dist/index.js",
     "selfcheck": "node ./scripts/selfcheck.mjs",
+    "selfcheck:release": "node ./scripts/selfcheck.mjs --release",
     "test": "node --import ./tests/register-ts-hooks.mjs --test ./tests/**/*.test.mjs",
     "check-register-drift": "node ./scripts/check-register-drift.mjs",
     "check-pack": "node ./scripts/check-pack.mjs",

package/scripts/check-pack.mjs

@@ -13,6 +13,7 @@ const requiredScriptFiles = [
   'scripts/check-pack.mjs',
   'scripts/check-register-drift.mjs',
   'scripts/selfcheck.mjs',
+  'scripts/version-policy.mjs',
 ];
 
 const requiredSourceFiles = [

package/scripts/selfcheck.mjs

@@ -3,6 +3,7 @@ import fs from 'node:fs';
 import { createRequire } from 'node:module';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { validateReleaseVersionPolicy, validateVersionSyntax } from './version-policy.mjs';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -10,6 +11,7 @@ const root = path.resolve(__dirname, '..');
 const require = createRequire(import.meta.url);
 
 const requiredRootFiles = ['index.ts', 'openclaw.plugin.json'];
+const requiredScriptFiles = ['scripts/version-policy.mjs'];
 
 const requiredSourceFiles = [
   'src/bootstrap/channel-plugin-runtime.ts',
@@ -213,7 +215,7 @@ const requiredSourceFiles = [
   'src/runtime/status-worker.ts',
 ];
 
-const requiredFiles = [...requiredRootFiles, ...requiredSourceFiles];
+const requiredFiles = [...requiredRootFiles, ...requiredScriptFiles, ...requiredSourceFiles];
 
 const readPackageVersion = () => {
   const pkgPath = path.join(root, 'package.json');
@@ -245,6 +247,7 @@ const requiredOpenClawSdkSubpaths = [
   'openclaw/plugin-sdk/core',
   'openclaw/plugin-sdk/json-store',
   'openclaw/plugin-sdk/param-readers',
+  'openclaw/plugin-sdk/media-runtime',
   'openclaw/plugin-sdk/security-runtime',
   'openclaw/plugin-sdk/status-helpers',
   'openclaw/plugin-sdk/tool-send',
@@ -266,120 +269,14 @@ const resolveOpenClawSdkSubpaths = () => {
   });
 };
 
-const validateVersionPolicy = (version, latestVersion) => {
-  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
-  if (!match) {
-    return {
-      ok: false,
-      reason: 'version must be strict semver x.y.z',
-      version,
-    };
-  }
-
-  const patch = Number.parseInt(match[3], 10);
-  if (patch > 9) {
-    return {
-      ok: false,
-      reason: 'patch version must stay within 0-9; bump minor instead',
-      version,
-    };
-  }
-
-  // Prevent jumping minor when current minor still has unused patch slots
-  if (latestVersion) {
-    const lm = latestVersion.match(/^(\d+)\.(\d+)\.(\d+)$/);
-    if (lm) {
-      const vMajor = Number.parseInt(match[1], 10);
-      const vMinor = Number.parseInt(match[2], 10);
-      const lMajor = Number.parseInt(lm[1], 10);
-      const lMinor = Number.parseInt(lm[2], 10);
-      const lPatch = Number.parseInt(lm[3], 10);
-
-      // Version unchanged
-      if (vMajor === lMajor && vMinor === lMinor && patch === lPatch) {
-        return { ok: false, reason: `version unchanged: ${version}`, version };
-      }
-
-      // Downgrade: any component decreased
-      if (
-        vMajor < lMajor ||
-        (vMajor === lMajor && vMinor < lMinor) ||
-        (vMajor === lMajor && vMinor === lMinor && patch < lPatch)
-      ) {
-        return { ok: false, reason: `downgrade from ${latestVersion} to ${version}`, version };
-      }
-
-      // Patch bump: same major and minor, patch must increment by exactly +1
-      if (vMajor === lMajor && vMinor === lMinor) {
-        if (patch === lPatch + 1) return { ok: true, version };
-        return {
-          ok: false,
-          reason: `patch jump from ${latestVersion} to ${version} (delta=${patch - lPatch}); expected ${lMajor}.${lMinor}.${lPatch + 1}`,
-          version,
-        };
-      }
-
-      // Minor bump: same major, minor + 1
-      if (vMajor === lMajor && vMinor === lMinor + 1) {
-        if (lPatch === 9 && patch === 0) return { ok: true, version };
-        if (lPatch !== 9)
-          return {
-            ok: false,
-            reason: `minor bumped from ${latestVersion} to ${version} but ${9 - lPatch} patch slots remain in ${lMajor}.${lMinor}; prefer ${lMajor}.${lMinor}.${lPatch + 1}`,
-            version,
-          };
-        return {
-          ok: false,
-          reason: `minor bump must reset patch to 0; got ${vMajor}.${vMinor}.${patch}`,
-          version,
-        };
-      }
-
-      // Minor jumped by more than 1
-      if (vMajor === lMajor && vMinor > lMinor + 1) {
-        return {
-          ok: false,
-          reason: `minor jumped from ${latestVersion} to ${version}; expected ${lMajor}.${lMinor + 1}.0`,
-          version,
-        };
-      }
-
-      // Major bump: major + 1, requires previous minor fully exhausted
-      if (vMajor === lMajor + 1) {
-        if (lMinor === 9 && lPatch === 9 && vMinor === 0 && patch === 0)
-          return { ok: true, version };
-        if (lMinor !== 9 || lPatch !== 9)
-          return {
-            ok: false,
-            reason: `major bumped from ${latestVersion} to ${version} but previous major series not exhausted; expected ${lMajor + 1}.0.0 after ${lMajor}.9.9`,
-            version,
-          };
-        return {
-          ok: false,
-          reason: `major bump must reset to .0.0; got ${vMajor}.${vMinor}.${patch}`,
-          version,
-        };
-      }
-
-      // Major jumped by more than 1
-      if (vMajor > lMajor + 1) {
-        return {
-          ok: false,
-          reason: `major jumped from ${latestVersion} to ${version}; expected ${lMajor + 1}.0.0`,
-          version,
-        };
-      }
-    }
-  }
-
-  return { ok: true, version };
-};
-
 const missing = requiredFiles.filter((rel) => !fs.existsSync(path.join(root, rel)));
 const version = readPackageVersion();
 const packageName = '@xmoxmo/bncr';
-const latestVersion = readNpmLatestVersion(packageName);
-const versionPolicy = validateVersionPolicy(version, latestVersion);
+const releaseMode = process.argv.includes('--release');
+const latestVersion = releaseMode ? readNpmLatestVersion(packageName) : null;
+const versionPolicy = releaseMode
+  ? validateReleaseVersionPolicy(version, latestVersion)
+  : validateVersionSyntax(version);
 const sdkSubpaths = resolveOpenClawSdkSubpaths();
 const missingSdkSubpaths = sdkSubpaths.filter((entry) => !entry.ok);
 const result = {
@@ -388,6 +285,8 @@ const result = {
   requiredCount: requiredFiles.length,
   missing,
   version,
+  versionMode: releaseMode ? 'release' : 'development',
+  latestVersion,
   versionPolicy,
   sdkSubpaths,
 };

package/scripts/version-policy.mjs

@@ -0,0 +1,75 @@
+export const validateVersionSyntax = (version) => {
+  const match = version.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!match) {
+    return {
+      ok: false,
+      reason: 'version must be strict semver x.y.z',
+      version,
+    };
+  }
+
+  const patch = Number.parseInt(match[3], 10);
+  if (patch > 9) {
+    return {
+      ok: false,
+      reason: 'patch version must stay within 0-9; bump minor instead',
+      version,
+    };
+  }
+
+  return { ok: true, version };
+};
+
+export const validateReleaseVersionPolicy = (version, latestVersion) => {
+  const versionPolicy = validateVersionSyntax(version);
+  if (!versionPolicy.ok) return versionPolicy;
+
+  if (!latestVersion) {
+    return {
+      ok: false,
+      reason: 'cannot verify release version: npm latest version is unavailable',
+      version,
+    };
+  }
+
+  const latestMatch = latestVersion.match(/^(\d+)\.(\d+)\.(\d+)$/);
+  if (!latestMatch) {
+    return {
+      ok: false,
+      reason: `invalid npm latest version: ${latestVersion}`,
+      version,
+    };
+  }
+
+  const latestMajor = Number.parseInt(latestMatch[1], 10);
+  const latestMinor = Number.parseInt(latestMatch[2], 10);
+  const latestPatch = Number.parseInt(latestMatch[3], 10);
+  if (latestPatch > 9) {
+    return {
+      ok: false,
+      reason: `invalid npm latest version: patch must stay within 0-9 (${latestVersion})`,
+      version,
+    };
+  }
+
+  const expected =
+    latestPatch < 9
+      ? `${latestMajor}.${latestMinor}.${latestPatch + 1}`
+      : latestMinor < 9
+        ? `${latestMajor}.${latestMinor + 1}.0`
+        : `${latestMajor + 1}.0.0`;
+
+  if (version !== expected) {
+    return {
+      ok: false,
+      reason: `release version must be exactly one valid step after ${latestVersion}: expected ${expected}, got ${version}`,
+      version,
+    };
+  }
+
+  return {
+    ok: true,
+    mode: 'release',
+    version,
+  };
+};

package/src/channel.ts

@@ -201,6 +201,7 @@ import {
   createBncrOutboxDiagnosticsHelpers,
   createBncrRuntimeAckObservabilityBuilder,
 } from './plugin/runtime-diagnostics-snapshot.ts';
+import { buildRouteSceneKey } from './plugin/scene-registry.ts';
 import { BNCR_SETUP_SURFACE } from './plugin/setup.ts';
 import type { BncrHistoryShardRow } from './plugin/sqlite-state.ts';
 import { createBncrStateTransientRuntimeGroup } from './plugin/state-transient-runtime-group.ts';
@@ -230,6 +231,10 @@ class BncrBridgeRuntime {
   // Identity / lifecycle ----------------------------------------------------
   private api: OpenClawPluginApi;
 
+  getApi(): OpenClawPluginApi {
+    return this.api;
+  }
+
   private get runtimeApi(): OpenClawPluginApi {
     return this.api;
   }
@@ -309,6 +314,12 @@ class BncrBridgeRuntime {
   getSceneRegistry(): Map<string, BncrSceneRecord> {
     return this.sceneRegistry;
   }
+  resolveOutboundAgentId(route: BncrRoute): string {
+    return (
+      asString(this.sceneRegistry.get(buildRouteSceneKey(route))?.agentId).trim() ||
+      this.defaultPublicAgentId()
+    );
+  }
   private conversationHistories: BncrConversationHistoryMap = new Map();
   private outboundReplayCache: BncrOutboundReplayCache = new Map();
   private routeAliases = new Map<
@@ -3228,6 +3239,7 @@ export function createBncrChannelPlugin(getBridge: () => BncrBridgeRuntime) {
   return createBncrChannelPluginSurfaceGroup({
     channelId: CHANNEL_ID,
     sceneRegistry: getBridge().getSceneRegistry(),
+    getApi: () => getBridge().getApi(),
     getMessageSendBridge: bridgeGroup.getMessageSendBridge,
     getOutboundBridge: bridgeGroup.getOutboundBridge,
     getMessagingBridge: bridgeGroup.getMessagingBridge,

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

@@ -27,12 +27,11 @@ type BncrOutboundSessionRoute = ChannelOutboundSessionRoute & BncrChannelRouteRe
 type ResolveBncrOutboundSessionRouteParams = {
   cfg: BncrChannelConfigRoot;
   channel: string;
-  agentId: string;
   accountId?: string;
   target: string;
   resolvedTarget?: { to?: string } | null;
   threadId?: string | number | null;
-  canonicalAgentId: string;
+  resolveAgentId: (route: BncrRoute) => string;
   resolveRouteBySession?: (raw: string, accountId: string) => BncrRoute | null;
 };
 
@@ -76,15 +75,14 @@ export function resolveBncrOutboundSessionRoute(params: ResolveBncrOutboundSessi
 
   if (!route) return null;
 
-  const canonicalAgentId =
-    asString(params.canonicalAgentId).trim() || asString(params.agentId).trim() || 'main';
+  const agentId = asString(params.resolveAgentId(route)).trim() || 'public';
   const peerId = routeScopeToHex(route);
-  const sessionKey = buildCanonicalBncrSessionKey(route, canonicalAgentId);
+  const sessionKey = buildCanonicalBncrSessionKey(route, agentId);
   const displayTo = formatDisplayScope(route);
 
   const built = buildOpenClawChannelOutboundSessionRoute({
     cfg: params.cfg,
-    agentId: canonicalAgentId,
+    agentId,
     channel: params.channel,
     accountId: params.accountId,
     peer: {

package/src/openclaw/media-runtime.ts

@@ -1,5 +1,9 @@
 import { existsSync } from 'node:fs';
 import path from 'node:path';
+import { canonicalizeBase64, estimateBase64DecodedBytes } from 'openclaw/plugin-sdk/media-runtime';
+
+export const OPENCLAW_SEND_BUFFER_MEDIA_URL = 'buffer://message-send/attachment';
+export const OPENCLAW_OUTBOUND_MEDIA_MAX_BYTES = 50 * 1024 * 1024;
 
 type RuntimeMediaLoaded = {
   buffer: Buffer;
@@ -39,6 +43,114 @@ type RuntimeApiHolder = {
 
 export type OpenClawLoadedMedia = RuntimeMediaLoaded;
 
+type OpenClawSendBufferDecodeResult = {
+  buffer: Buffer;
+  mimeType?: string;
+  fileName?: string;
+};
+
+function normalizeOptionalString(value: string | undefined): string | undefined {
+  const normalized = String(value || '').trim();
+  return normalized || undefined;
+}
+
+function isPathInsideRoot(candidate: string, root: string): boolean {
+  const relative = path.relative(root, candidate);
+  return (
+    relative === '' ||
+    (relative !== '..' && !path.isAbsolute(relative) && !relative.startsWith(`..${path.sep}`))
+  );
+}
+
+/**
+ * Translate a sandbox container workspace path into an authorized host path.
+ *
+ * `extra.path` bypasses host-side sandbox staging, so a path such as
+ * `/workspace/file.js` reaches the plugin unchanged. Resolve it only against
+ * roots supplied by the host and prefer the most specific matching root.
+ */
+function resolveContainerWorkspaceMediaPath(
+  mediaUrl: string,
+  localRoots?: readonly string[],
+): string {
+  if (!localRoots?.length || !/^\/workspace(?:\/|$)/.test(mediaUrl)) {
+    return mediaUrl;
+  }
+  if (existsSync(mediaUrl)) {
+    return mediaUrl;
+  }
+
+  const relativePath = mediaUrl.slice('/workspace'.length).replace(/^\/+/, '');
+  if (!relativePath) {
+    return mediaUrl;
+  }
+
+  let bestMatch: { root: string; candidate: string } | undefined;
+  for (const root of localRoots) {
+    const resolvedRoot = path.resolve(root);
+    const candidate = path.resolve(resolvedRoot, relativePath);
+    if (!isPathInsideRoot(candidate, resolvedRoot) || !existsSync(candidate)) {
+      continue;
+    }
+    if (!bestMatch || resolvedRoot.length > bestMatch.root.length) {
+      bestMatch = { root: resolvedRoot, candidate };
+    }
+  }
+
+  return bestMatch?.candidate ?? mediaUrl;
+}
+
+export function isOpenClawSendBufferMediaUrl(mediaUrl: string): boolean {
+  return String(mediaUrl || '').trim() === OPENCLAW_SEND_BUFFER_MEDIA_URL;
+}
+
+export function decodeOpenClawSendBuffer(params: {
+  buffer: string;
+  contentType?: string;
+  mimeType?: string;
+  filename?: string;
+  fileName?: string;
+  maxBytes?: number;
+}): OpenClawSendBufferDecodeResult {
+  const raw = String(params.buffer || '').trim();
+  const match = /^data:([^;,\s]+)(;(?!base64)[^,;\s]+)*;base64,(.*)$/is.exec(raw);
+  const encoded = match ? match[3] : raw;
+  if (!encoded.trim()) {
+    throw new Error('send buffer base64 decoded to empty buffer');
+  }
+  const canonical = canonicalizeBase64(encoded);
+  if (!canonical) {
+    throw new Error('send buffer has invalid base64 data');
+  }
+
+  const maxBytes = params.maxBytes ?? OPENCLAW_OUTBOUND_MEDIA_MAX_BYTES;
+  const estimatedBytes = estimateBase64DecodedBytes(canonical);
+  if (estimatedBytes > maxBytes) {
+    throw new Error(
+      `send buffer media too large: estimated ${estimatedBytes} bytes exceeds ${maxBytes} bytes`,
+    );
+  }
+
+  const buffer = Buffer.from(canonical, 'base64');
+  if (!buffer.length) {
+    throw new Error('send buffer base64 decoded to empty buffer');
+  }
+  if (buffer.byteLength > maxBytes) {
+    throw new Error(
+      `send buffer media too large: decoded ${buffer.byteLength} bytes exceeds ${maxBytes} bytes`,
+    );
+  }
+
+  return {
+    buffer,
+    mimeType:
+      normalizeOptionalString(params.contentType) ??
+      normalizeOptionalString(params.mimeType) ??
+      normalizeOptionalString(match?.[1]),
+    fileName: normalizeOptionalString(params.filename) ?? normalizeOptionalString(params.fileName),
+  };
+}
+
 export function isOpenClawRemoteHttpMediaUrl(mediaUrl: string): boolean {
   return /^https?:\/\//i.test(String(mediaUrl || '').trim());
 }
@@ -50,6 +162,8 @@ export function isOpenClawRemoteHttpMediaUrl(mediaUrl: string): boolean {
  */
 function resolveRelativeMediaPath(mediaUrl: string, localRoots?: readonly string[]): string {
   if (!mediaUrl || !localRoots?.length) return mediaUrl;
+  const containerWorkspacePath = resolveContainerWorkspaceMediaPath(mediaUrl, localRoots);
+  if (containerWorkspacePath !== mediaUrl) return containerWorkspacePath;
   if (path.isAbsolute(mediaUrl)) return mediaUrl;
   // HTTP / file:// / data: / ~ paths are handled elsewhere
   if (/^(https?|file|data):/i.test(mediaUrl) || mediaUrl.startsWith('~')) return mediaUrl;

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

@@ -34,6 +34,7 @@ export type BncrChannelPluginBridge = {
     channelId: string;
     peer: { kind: 'direct'; id: string };
   }) => string;
+  resolveOutboundAgentId: (route: BncrRoute) => string;
   resolveRouteBySession: (raw: string, accountId: string) => BncrRoute | null;
   getChannelSummary: (defaultAccountId: string) => Record<string, unknown>;
   getAccountRuntimeSnapshot: (accountId: string) => BncrStatusRuntimeSnapshot;
@@ -90,14 +91,7 @@ export function createBncrChannelPluginBridgeGroup(runtime: {
   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 },
-        }),
+      resolveOutboundAgentId: (route: BncrRoute) => bridge.resolveOutboundAgentId(route),
       resolveRouteBySession: (raw: string, accountId: string) =>
         bridge.resolveRouteBySession(raw, accountId),
     };

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

@@ -3,13 +3,19 @@ import { Type } from 'typebox';
 import { listAccountIds, normalizeAccountId, resolveAccount } from '../core/accounts.ts';
 import { BncrConfigSchema } from '../core/config-schema.ts';
 import { resolveBncrChannelPolicy } from '../core/policy.ts';
+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 {
+  decodeOpenClawSendBuffer,
+  isOpenClawSendBufferMediaUrl,
+  OPENCLAW_OUTBOUND_MEDIA_MAX_BYTES,
+  saveOpenClawChannelMediaBuffer,
+} from '../openclaw/media-runtime.ts';
 import type { OpenClawChannelToolSend, openClawJsonResult } from '../openclaw/sdk-helpers.ts';
 import { readOpenClawStringParam } from '../openclaw/sdk-helpers.ts';
 import type { BncrBridgeCallBridge } from './bridge-call.ts';
 import type {
-  BncrChannelConfigRoot,
   BncrChannelSendContext,
   BncrMessageToolSchemaContribution,
   BncrSceneRecord,
@@ -68,6 +74,7 @@ const BNCR_MESSAGE_TOOL_SCHEMA: BncrMessageToolSchemaContribution = {
 export function createBncrChannelPluginSurfaceGroup(runtime: {
   channelId: string;
   sceneRegistry: Map<string, BncrSceneRecord>;
+  getApi: () => Parameters<typeof saveOpenClawChannelMediaBuffer>[0];
   getMessageSendBridge: () => {
     channelMessageSendText: (
       ctx: Record<string, unknown>,
@@ -81,8 +88,7 @@ export function createBncrChannelPluginSurfaceGroup(runtime: {
   };
   getOutboundBridge: () => BncrOutboundBridge;
   getMessagingBridge: () => {
-    canonicalAgentId: undefined;
-    ensureCanonicalAgentId: (params: { cfg: BncrChannelConfigRoot; accountId: string }) => string;
+    resolveOutboundAgentId: (route: BncrRoute) => string;
     resolveRouteBySession: (raw: string, accountId: string) => BncrVerifiedTarget['route'] | null;
   };
   getStatusBridge: () => {
@@ -223,20 +229,49 @@ export function createBncrChannelPluginSurfaceGroup(runtime: {
       }
 
       const to = readOpenClawStringParam(paramsObj, 'to', { required: true });
-      const toolMediaUrl =
+      const rawBuffer = typeof paramsObj.buffer === 'string' ? paramsObj.buffer : '';
+      const rawMediaUrl =
         (typeof paramsObj.mediaUrl === 'string' ? paramsObj.mediaUrl : '') ||
         (typeof paramsObj.media === 'string' ? paramsObj.media : '') ||
         (typeof paramsObj.path === 'string' ? paramsObj.path : '') ||
         (typeof paramsObj.filePath === 'string' ? paramsObj.filePath : '');
+      const rawMediaUrls = paramsObj.mediaUrls;
+      const declaredMediaUrls = Array.isArray(rawMediaUrls)
+        ? rawMediaUrls.filter((u): u is string => typeof u === 'string')
+        : undefined;
+      const hasExplicitMedia = [rawMediaUrl, ...(declaredMediaUrls ?? [])].some(
+        (mediaUrl) => Boolean(mediaUrl) && !isOpenClawSendBufferMediaUrl(mediaUrl),
+      );
+      let toolMediaUrl = rawMediaUrl;
+      let mediaUrls = declaredMediaUrls;
+      if (rawBuffer && !hasExplicitMedia) {
+        const decoded = decodeOpenClawSendBuffer({
+          buffer: rawBuffer,
+          contentType:
+            typeof paramsObj.contentType === 'string' ? paramsObj.contentType : undefined,
+          mimeType: typeof paramsObj.mimeType === 'string' ? paramsObj.mimeType : undefined,
+          filename: typeof paramsObj.filename === 'string' ? paramsObj.filename : undefined,
+          fileName: typeof paramsObj.fileName === 'string' ? paramsObj.fileName : undefined,
+          maxBytes: OPENCLAW_OUTBOUND_MEDIA_MAX_BYTES,
+        });
+        const saved = await saveOpenClawChannelMediaBuffer(
+          runtime.getApi(),
+          decoded.buffer,
+          decoded.mimeType,
+          'outbound',
+          OPENCLAW_OUTBOUND_MEDIA_MAX_BYTES,
+          decoded.fileName,
+        );
+        toolMediaUrl = saved.path;
+        mediaUrls = declaredMediaUrls?.map((mediaUrl) =>
+          isOpenClawSendBufferMediaUrl(mediaUrl) ? saved.path : mediaUrl,
+        );
+      }
       const rawExtra = paramsObj.extra;
       const extra =
         rawExtra && typeof rawExtra === 'object' && !Array.isArray(rawExtra)
           ? (rawExtra as Record<string, unknown>)
           : undefined;
-      const rawMediaUrls = paramsObj.mediaUrls;
-      const mediaUrls = Array.isArray(rawMediaUrls)
-        ? rawMediaUrls.filter((u): u is string => typeof u === 'string')
-        : undefined;
 
       const toolMessage = readOpenClawStringParam(paramsObj, 'message', { allowEmpty: true }) ?? '';
       const toolCaption = readOpenClawStringParam(paramsObj, 'caption', { allowEmpty: true }) ?? '';

package/src/plugin/messaging.ts

@@ -15,8 +15,7 @@ function formatBncrHumanDisplay(route: BncrRoute): string {
 }
 
 type BncrMessagingRuntimeBridge = {
-  canonicalAgentId?: string;
-  ensureCanonicalAgentId: (params: { cfg: BncrChannelConfigRoot; accountId: string }) => string;
+  resolveOutboundAgentId: (route: BncrRoute) => string;
   resolveRouteBySession: (raw: string, accountId: string) => BncrRoute | null;
 };
 
@@ -44,6 +43,7 @@ type BncrMessagingSessionTargetArgs = {
 };
 
 type BncrMessagingOutboundSessionRouteArgs = {
+  /** Host-reported owner. BNCR resolves ownership from its persisted scene registry instead. */
   agentId: string;
   target: string;
   resolvedTarget?: { to?: string } | null;
@@ -99,21 +99,9 @@ function resolveMessagingAccountId(accountId: unknown) {
   return normalizeAccountId(asSanitizedString(accountId || BNCR_DEFAULT_ACCOUNT_ID));
 }
 
-function resolveMessagingCanonicalAgentId(
-  runtimeBridge: BncrMessagingRuntimeBridge,
-  cfg: BncrChannelConfigRoot,
-  accountId: string,
-) {
-  return runtimeBridge.canonicalAgentId || runtimeBridge.ensureCanonicalAgentId({ cfg, accountId });
-}
-
-export function createBncrMessagingExplicitTargetParser(
-  getBridge: () => BncrMessagingRuntimeBridge,
-) {
+export function createBncrMessagingExplicitTargetParser() {
   return ({ raw }: BncrMessagingExplicitTargetArgs) => {
-    const runtimeBridge = getBridge();
-    const canonicalAgentId = runtimeBridge.canonicalAgentId || 'main';
-    const parsed = parseExplicitTarget(asSanitizedString(raw).trim(), { canonicalAgentId });
+    const parsed = parseExplicitTarget(asSanitizedString(raw).trim());
     if (!parsed) return null;
     const chatType: ChatType = parsed.route?.groupId ? 'group' : 'direct';
     return {
@@ -125,16 +113,12 @@ export function createBncrMessagingExplicitTargetParser(
   };
 }
 
-export function createBncrMessagingSessionTargetResolver(
-  getBridge: () => BncrMessagingRuntimeBridge,
-) {
+export function createBncrMessagingSessionTargetResolver() {
   return ({ id }: BncrMessagingSessionTargetArgs) => {
     const raw = asSanitizedString(id).trim();
     if (!raw) return undefined;
-    const runtimeBridge = getBridge();
-    const canonicalAgentId = runtimeBridge.canonicalAgentId || 'main';
 
-    const parsed = parseExplicitTarget(raw, { canonicalAgentId });
+    const parsed = parseExplicitTarget(raw);
     if (!parsed) {
       return raw || undefined;
     }
@@ -146,17 +130,10 @@ export function createBncrMessagingOutboundSessionRouteResolver(
   getBridge: () => BncrMessagingRuntimeBridge,
 ) {
   return (params: BncrMessagingOutboundSessionRouteArgs) => {
-    const accountId = resolveMessagingAccountId(params?.accountId);
     const runtimeBridge = getBridge();
-    const canonicalAgentId = resolveMessagingCanonicalAgentId(
-      runtimeBridge,
-      params?.cfg,
-      accountId,
-    );
     return resolveBncrOutboundSessionRoute({
       channel: 'bncr',
       cfg: params.cfg,
-      agentId: params.agentId,
       accountId: params.accountId ?? undefined,
       target: params.target,
       resolvedTarget: params.resolvedTarget,
@@ -164,7 +141,7 @@ export function createBncrMessagingOutboundSessionRouteResolver(
         params.threadId === null || params.threadId === undefined
           ? undefined
           : asSanitizedString(params.threadId),
-      canonicalAgentId,
+      resolveAgentId: (route) => runtimeBridge.resolveOutboundAgentId(route),
       resolveRouteBySession: (raw: string, acc: string) =>
         runtimeBridge.resolveRouteBySession(raw, acc),
     });
@@ -175,9 +152,9 @@ export function createBncrMessagingSurface(getBridge: () => BncrMessagingRuntime
   return {
     // 接收任意标签输入；不在 normalize 阶段做格式门槛，统一下沉到发送前验证。
     normalizeTarget: normalizeBncrMessagingTarget,
-    parseExplicitTarget: createBncrMessagingExplicitTargetParser(getBridge),
+    parseExplicitTarget: createBncrMessagingExplicitTargetParser(),
     formatTargetDisplay: formatBncrMessagingTargetDisplay,
-    resolveSessionTarget: createBncrMessagingSessionTargetResolver(getBridge),
+    resolveSessionTarget: createBncrMessagingSessionTargetResolver(),
     resolveOutboundSessionRoute: createBncrMessagingOutboundSessionRouteResolver(getBridge),
     targetResolver: createBncrMessagingTargetResolver(getBridge),
   };

package/src/plugin/scene-registry.ts

@@ -1,3 +1,5 @@
+import type { BncrRoute } from '../core/types.ts';
+import { asString } from '../core/value-sanitize.ts';
 import type {
   BncrGroupReplyMode,
   BncrSceneKind,
@@ -30,10 +32,19 @@ function defaultGroupReplyMode(kind: BncrSceneKind): BncrGroupReplyMode | undefi
   return kind === 'group' ? 'admin' : undefined;
 }
 
+export function buildRouteSceneKey(route: BncrRoute): string {
+  const platform = asString(route.platform).trim();
+  const groupId = asString(route.groupId).trim() || '0';
+  const userId = asString(route.userId).trim() || '0';
+  return groupId !== '0' ? `${platform}:${groupId}` : `${platform}:${userId}`;
+}
+
 export function buildSceneKey(parsed: ParsedInbound): string {
-  return parsed.peer.kind === 'group'
-    ? `${parsed.platform}:${parsed.groupId}`
-    : `${parsed.platform}:${parsed.userId}`;
+  return buildRouteSceneKey({
+    platform: parsed.platform,
+    groupId: parsed.groupId || '0',
+    userId: parsed.userId || '0',
+  });
 }
 
 function buildSceneRecord(args: {