@xmoxmo/bncr 0.2.5 → 0.2.7

package/src/messaging/outbound/retry-policy.ts

@@ -1,5 +1,11 @@
 import type { BncrRoute } from '../../channel.ts';
 
+function finiteNonNegativeIntegerOr(value: unknown, fallback: number): number {
+  const n = Number(value);
+  if (!Number.isFinite(n) || n < 0) return fallback;
+  return Math.floor(n);
+}
+
 export type RetryRerouteDecisionInput = {
   nowMs: number;
   maxRetry: number;
@@ -51,7 +57,9 @@ export function computeRetryRerouteDecision(
   const hasUntriedAlternative = availableConnIds.some((connId) => !attemptedConnIds.includes(connId));
   const shouldFastReroute = input.requireAck && input.currentFastReroutePending !== true && hasUntriedAlternative;
 
-  const nextRetryCount = Number(input.currentRetryCount || 0) + 1;
+  const currentRetryCount = finiteNonNegativeIntegerOr(input.currentRetryCount, 0);
+  const currentRouteAttemptRound = finiteNonNegativeIntegerOr(input.currentRouteAttemptRound, 0);
+  const nextRetryCount = currentRetryCount + 1;
   const lastAttemptAt = input.nowMs;
   const terminalReason =
     input.lastError || (input.requireAck ? 'push-ack-timeout' : 'push-delivery-unconfirmed');
@@ -67,7 +75,7 @@ export function computeRetryRerouteDecision(
 
   const nextAttemptAt = shouldFastReroute ? input.nowMs + 1_000 : input.nowMs + deps.backoffMs(nextRetryCount);
   const lastError = input.requireAck ? 'push-ack-timeout' : 'push-delivery-unconfirmed';
-  const routeAttemptRound = hasUntriedAlternative ? Number(input.currentRouteAttemptRound || 0) : Number(input.currentRouteAttemptRound || 0) + 1;
+  const routeAttemptRound = hasUntriedAlternative ? currentRouteAttemptRound : currentRouteAttemptRound + 1;
   const fastReroutePending = hasUntriedAlternative ? shouldFastReroute || input.currentFastReroutePending === true : false;
 
   return {
@@ -111,7 +119,8 @@ export function computePushFailureDecision(
   input: PushFailureDecisionInput,
   deps: { backoffMs: (retryCount: number) => number },
 ): PushFailureDecision {
-  const nextRetryCount = Number(input.currentRetryCount || 0) + 1;
+  const currentRetryCount = finiteNonNegativeIntegerOr(input.currentRetryCount, 0);
+  const nextRetryCount = currentRetryCount + 1;
   const lastAttemptAt = input.nowMs;
 
   if (nextRetryCount > input.maxRetry) {

package/src/messaging/outbound/send.ts

@@ -3,6 +3,7 @@ export async function sendBncrText(params: {
   accountId: string;
   to: string;
   text: string;
+  kind?: 'tool' | 'block' | 'final';
   replyToId?: string;
   mediaLocalRoots?: readonly string[];
   resolveVerifiedTarget: (
@@ -18,6 +19,7 @@ export async function sendBncrText(params: {
       text?: string;
       mediaUrl?: string;
       mediaUrls?: string[];
+      kind?: 'tool' | 'block' | 'final';
       replyToId?: string;
     };
     mediaLocalRoots?: readonly string[];
@@ -33,6 +35,7 @@ export async function sendBncrText(params: {
     route: verified.route,
     payload: {
       text: params.text,
+      kind: params.kind,
       replyToId: params.replyToId,
     },
     mediaLocalRoots: params.mediaLocalRoots,
@@ -54,6 +57,7 @@ export async function sendBncrMedia(params: {
   mediaUrls?: string[];
   asVoice?: boolean;
   audioAsVoice?: boolean;
+  kind?: 'tool' | 'block' | 'final';
   replyToId?: string;
   mediaLocalRoots?: readonly string[];
   resolveVerifiedTarget: (
@@ -71,6 +75,7 @@ export async function sendBncrMedia(params: {
       mediaUrls?: string[];
       asVoice?: boolean;
       audioAsVoice?: boolean;
+      kind?: 'tool' | 'block' | 'final';
       replyToId?: string;
     };
     mediaLocalRoots?: readonly string[];
@@ -90,6 +95,7 @@ export async function sendBncrMedia(params: {
       mediaUrls: params.mediaUrls?.length ? params.mediaUrls : undefined,
       asVoice: params.asVoice === true ? true : undefined,
       audioAsVoice: params.audioAsVoice === true ? true : undefined,
+      kind: params.kind,
       replyToId: params.replyToId,
     },
     mediaLocalRoots: params.mediaLocalRoots,

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

@@ -1,4 +1,4 @@
-import { buildChannelOutboundSessionRoute } from 'openclaw/plugin-sdk/core';
+import { buildOpenClawChannelOutboundSessionRoute } from '../../openclaw/session-route-runtime.ts';
 import {
   buildCanonicalBncrSessionKey,
   formatDisplayScope,
@@ -72,7 +72,7 @@ export function resolveBncrOutboundSessionRoute(params: ResolveBncrOutboundSessi
   const sessionKey = buildCanonicalBncrSessionKey(route, canonicalAgentId);
   const displayTo = formatDisplayScope(route);
 
-  const built = buildChannelOutboundSessionRoute({
+  const built = buildOpenClawChannelOutboundSessionRoute({
     cfg: params.cfg,
     agentId: canonicalAgentId,
     channel: params.channel,

package/src/openclaw/config-runtime.ts

@@ -0,0 +1,52 @@
+type RuntimeConfigApi = {
+  current?: () => unknown;
+  get?: () => unknown;
+  mutateConfigFile?: (params: {
+    afterWrite?: { mode?: string };
+    mutate: (draft: Record<string, unknown>) => void;
+  }) => Promise<unknown> | unknown;
+};
+
+type RuntimeApiHolder = {
+  runtime?: {
+    config?: RuntimeConfigApi;
+  };
+};
+
+function resolveConfigApi(api: RuntimeApiHolder): RuntimeConfigApi {
+  const config = api?.runtime?.config;
+  if (!config) throw new Error('OpenClaw runtime config API is unavailable');
+  return config;
+}
+
+export function getOpenClawRuntimeConfig(api: RuntimeApiHolder): unknown {
+  const config = resolveConfigApi(api);
+  if (typeof config.current === 'function') return config.current();
+  if (typeof config.get === 'function') return config.get();
+  throw new Error('OpenClaw runtime config read API is unavailable');
+}
+
+export function getOpenClawRuntimeConfigOrDefault<T>(
+  api: RuntimeApiHolder,
+  fallback: T,
+): unknown | T {
+  try {
+    return getOpenClawRuntimeConfig(api);
+  } catch {
+    return fallback;
+  }
+}
+
+export async function mutateOpenClawRuntimeConfigFile(
+  api: RuntimeApiHolder,
+  params: {
+    afterWrite?: { mode?: string };
+    mutate: (draft: Record<string, unknown>) => void;
+  },
+): Promise<unknown> {
+  const config = resolveConfigApi(api);
+  if (typeof config.mutateConfigFile !== 'function') {
+    throw new Error('OpenClaw runtime config mutate API is unavailable');
+  }
+  return config.mutateConfigFile(params);
+}

package/src/openclaw/inbound-session-runtime.ts

@@ -0,0 +1,94 @@
+import { recordInboundSession as sdkRecordInboundSession } from 'openclaw/plugin-sdk/conversation-runtime';
+import { resolvePinnedMainDmOwnerFromAllowlist as sdkResolvePinnedMainDmOwnerFromAllowlist } from 'openclaw/plugin-sdk/security-runtime';
+import {
+  recordSessionMetaFromInbound as sdkRecordSessionMetaFromInbound,
+  resolveStorePath as sdkResolveStorePath,
+  updateSessionStoreEntry as sdkUpdateSessionStoreEntry,
+} from 'openclaw/plugin-sdk/session-store-runtime';
+
+type ResolveStorePathFn = (storeConfig: unknown, options: { agentId: string }) => string;
+type RecordInboundSessionFn = typeof sdkRecordInboundSession;
+type RecordSessionMetaFromInboundFn = typeof sdkRecordSessionMetaFromInbound;
+type UpdateSessionStoreEntryFn = typeof sdkUpdateSessionStoreEntry;
+type ReadSessionUpdatedAtFn = (params: { storePath: string; sessionKey: string }) => unknown;
+type ResolvePinnedMainDmOwnerFromAllowlistFn = typeof sdkResolvePinnedMainDmOwnerFromAllowlist;
+
+type BncrInboundSessionRuntime = {
+  resolveStorePath: ResolveStorePathFn;
+  recordInboundSession: RecordInboundSessionFn;
+  recordSessionMetaFromInbound: RecordSessionMetaFromInboundFn;
+  updateSessionStoreEntry: UpdateSessionStoreEntryFn;
+  readSessionUpdatedAt?: ReadSessionUpdatedAtFn;
+  resolvePinnedMainDmOwnerFromAllowlist: ResolvePinnedMainDmOwnerFromAllowlistFn;
+};
+
+let testRuntimeOverride: Partial<BncrInboundSessionRuntime> | null = null;
+
+function resolveRuntime(): BncrInboundSessionRuntime {
+  return {
+    resolveStorePath: testRuntimeOverride?.resolveStorePath ?? sdkResolveStorePath,
+    recordInboundSession: testRuntimeOverride?.recordInboundSession ?? sdkRecordInboundSession,
+    recordSessionMetaFromInbound:
+      testRuntimeOverride?.recordSessionMetaFromInbound ?? sdkRecordSessionMetaFromInbound,
+    updateSessionStoreEntry:
+      testRuntimeOverride?.updateSessionStoreEntry ?? sdkUpdateSessionStoreEntry,
+    readSessionUpdatedAt: testRuntimeOverride?.readSessionUpdatedAt,
+    resolvePinnedMainDmOwnerFromAllowlist:
+      testRuntimeOverride?.resolvePinnedMainDmOwnerFromAllowlist ??
+      sdkResolvePinnedMainDmOwnerFromAllowlist,
+  };
+}
+
+export function resolveBncrInboundSessionStorePath(args: {
+  storeConfig: unknown;
+  agentId: string;
+}): string {
+  return resolveRuntime().resolveStorePath(args.storeConfig, { agentId: args.agentId });
+}
+
+export function recordBncrInboundSession(
+  params: Parameters<RecordInboundSessionFn>[0],
+): ReturnType<RecordInboundSessionFn> {
+  return resolveRuntime().recordInboundSession(params);
+}
+
+export function recordBncrSessionMetaFromInbound(
+  params: Parameters<RecordSessionMetaFromInboundFn>[0],
+): ReturnType<RecordSessionMetaFromInboundFn> {
+  return resolveRuntime().recordSessionMetaFromInbound(params);
+}
+
+export function updateBncrSessionStoreEntry(
+  params: Parameters<UpdateSessionStoreEntryFn>[0],
+): ReturnType<UpdateSessionStoreEntryFn> {
+  return resolveRuntime().updateSessionStoreEntry(params);
+}
+
+export function readBncrSessionUpdatedAt(
+  api: { runtime?: { channel?: { session?: { readSessionUpdatedAt?: ReadSessionUpdatedAtFn } } } },
+  params: { storePath: string; sessionKey: string },
+): unknown {
+  const runtime = resolveRuntime();
+  if (runtime.readSessionUpdatedAt) return runtime.readSessionUpdatedAt(params);
+  const readSessionUpdatedAt = api?.runtime?.channel?.session?.readSessionUpdatedAt;
+  if (typeof readSessionUpdatedAt !== 'function') {
+    throw new Error('OpenClaw channel session readSessionUpdatedAt API is unavailable');
+  }
+  return readSessionUpdatedAt(params);
+}
+
+export function resolveBncrPinnedMainDmOwnerFromAllowlist(
+  params: Parameters<ResolvePinnedMainDmOwnerFromAllowlistFn>[0],
+): ReturnType<ResolvePinnedMainDmOwnerFromAllowlistFn> {
+  return resolveRuntime().resolvePinnedMainDmOwnerFromAllowlist(params);
+}
+
+export function setBncrInboundSessionRuntimeForTest(
+  runtime: Partial<BncrInboundSessionRuntime> | null,
+): () => void {
+  const previous = testRuntimeOverride;
+  testRuntimeOverride = runtime;
+  return () => {
+    testRuntimeOverride = previous;
+  };
+}

package/src/openclaw/ingress-runtime.ts

@@ -0,0 +1,35 @@
+import {
+  defineStableChannelIngressIdentity as sdkDefineStableChannelIngressIdentity,
+  resolveChannelMessageIngress as sdkResolveChannelMessageIngress,
+} from 'openclaw/plugin-sdk/channel-ingress-runtime';
+
+export function defineOpenClawStableChannelIngressIdentity(params: {
+  key: string;
+  kind: string;
+  normalize: (value: string) => string | null;
+  sensitivity: 'public' | 'private' | 'pii' | string;
+  entryIdPrefix?: string;
+  aliases?: Array<{
+    key: string;
+    kind: string;
+    normalize: (value: string) => string | null;
+    sensitivity: 'public' | 'private' | 'pii' | string;
+  }>;
+}) {
+  return sdkDefineStableChannelIngressIdentity(params as any);
+}
+
+export async function resolveOpenClawChannelMessageIngress(params: {
+  channelId: string;
+  accountId: string;
+  identity: unknown;
+  subject: unknown;
+  conversation: unknown;
+  event: unknown;
+  policy: unknown;
+  allowFrom?: string[];
+  groupAllowFrom?: string[];
+  accessGroups?: unknown;
+}): Promise<any> {
+  return sdkResolveChannelMessageIngress(params as any);
+}

package/src/openclaw/media-runtime.ts

@@ -0,0 +1,73 @@
+type RuntimeMediaLoaded = {
+  buffer: Buffer;
+  contentType?: string;
+  fileName?: string;
+};
+
+type RuntimeMediaApi = {
+  loadWebMedia?: (
+    mediaUrl: string,
+    options?: { localRoots?: readonly string[]; maxBytes?: number },
+  ) => Promise<RuntimeMediaLoaded>;
+};
+
+type RuntimeChannelMediaApi = {
+  readRemoteMediaBuffer?: (options: {
+    url: string;
+    maxBytes?: number;
+  }) => Promise<RuntimeMediaLoaded>;
+  saveMediaBuffer?: (
+    buffer: Buffer,
+    mimeType: string | undefined,
+    direction: 'inbound' | 'outbound',
+    maxBytes: number,
+    fileName?: string,
+  ) => Promise<{ path: string }>;
+};
+
+type RuntimeApiHolder = {
+  runtime?: {
+    media?: RuntimeMediaApi;
+    channel?: {
+      media?: RuntimeChannelMediaApi;
+    };
+  };
+};
+
+export type OpenClawLoadedMedia = RuntimeMediaLoaded;
+
+export function isOpenClawRemoteHttpMediaUrl(mediaUrl: string): boolean {
+  return /^https?:\/\//i.test(String(mediaUrl || '').trim());
+}
+
+export async function loadOpenClawWebMedia(
+  api: RuntimeApiHolder,
+  mediaUrl: string,
+  options?: { localRoots?: readonly string[]; maxBytes?: number },
+): Promise<RuntimeMediaLoaded> {
+  const readRemoteMediaBuffer = api?.runtime?.channel?.media?.readRemoteMediaBuffer;
+  if (isOpenClawRemoteHttpMediaUrl(mediaUrl) && typeof readRemoteMediaBuffer === 'function') {
+    return readRemoteMediaBuffer({ url: mediaUrl, maxBytes: options?.maxBytes });
+  }
+
+  const loadWebMedia = api?.runtime?.media?.loadWebMedia;
+  if (typeof loadWebMedia !== 'function') {
+    throw new Error('OpenClaw runtime media loadWebMedia API is unavailable');
+  }
+  return loadWebMedia(mediaUrl, options);
+}
+
+export async function saveOpenClawChannelMediaBuffer(
+  api: RuntimeApiHolder,
+  buffer: Buffer,
+  mimeType: string | undefined,
+  direction: 'inbound' | 'outbound',
+  maxBytes: number,
+  fileName?: string,
+): Promise<{ path: string }> {
+  const saveMediaBuffer = api?.runtime?.channel?.media?.saveMediaBuffer;
+  if (typeof saveMediaBuffer !== 'function') {
+    throw new Error('OpenClaw channel media saveMediaBuffer API is unavailable');
+  }
+  return saveMediaBuffer(buffer, mimeType, direction, maxBytes, fileName);
+}

package/src/openclaw/reply-runtime.ts

@@ -0,0 +1,104 @@
+type RuntimeReplyApi = {
+  formatAgentEnvelope?: (params: {
+    channel: string;
+    from: string;
+    timestamp: number;
+    previousTimestamp?: unknown;
+    envelope?: unknown;
+    body: string;
+  }) => string;
+  resolveEnvelopeFormatOptions?: (cfg: unknown) => unknown;
+  dispatchReplyWithBufferedBlockDispatcher?: (params: {
+    ctx: unknown;
+    cfg: unknown;
+    dispatcherOptions: {
+      deliver: (
+        payload: {
+          text?: string;
+          mediaUrl?: string;
+          mediaUrls?: string[];
+          audioAsVoice?: boolean;
+        },
+        info?: { kind?: 'tool' | 'block' | 'final' },
+      ) => Promise<void> | void;
+      onError?: (err: unknown) => void;
+    };
+    replyOptions?: {
+      disableBlockStreaming?: boolean;
+      shouldEmitToolResult?: () => boolean;
+    };
+  }) => Promise<unknown> | unknown;
+};
+
+type RuntimeApiHolder = {
+  runtime?: {
+    channel?: {
+      reply?: RuntimeReplyApi;
+    };
+  };
+};
+
+function resolveReplyApi(api: RuntimeApiHolder): RuntimeReplyApi {
+  const reply = api?.runtime?.channel?.reply;
+  if (!reply) throw new Error('OpenClaw channel reply API is unavailable');
+  return reply;
+}
+
+export function resolveOpenClawEnvelopeFormatOptions(
+  api: RuntimeApiHolder,
+  cfg: unknown,
+): unknown {
+  const reply = resolveReplyApi(api);
+  if (typeof reply.resolveEnvelopeFormatOptions !== 'function') {
+    throw new Error('OpenClaw channel reply resolveEnvelopeFormatOptions API is unavailable');
+  }
+  return reply.resolveEnvelopeFormatOptions(cfg);
+}
+
+export function formatOpenClawAgentEnvelope(
+  api: RuntimeApiHolder,
+  params: {
+    channel: string;
+    from: string;
+    timestamp: number;
+    previousTimestamp?: unknown;
+    envelope?: unknown;
+    body: string;
+  },
+): string {
+  const reply = resolveReplyApi(api);
+  if (typeof reply.formatAgentEnvelope !== 'function') {
+    throw new Error('OpenClaw channel reply formatAgentEnvelope API is unavailable');
+  }
+  return reply.formatAgentEnvelope(params);
+}
+
+export async function dispatchOpenClawReplyWithBufferedBlockDispatcher(
+  api: RuntimeApiHolder,
+  params: {
+    ctx: unknown;
+    cfg: unknown;
+    dispatcherOptions: {
+      deliver: (
+        payload: {
+          text?: string;
+          mediaUrl?: string;
+          mediaUrls?: string[];
+          audioAsVoice?: boolean;
+        },
+        info?: { kind?: 'tool' | 'block' | 'final' },
+      ) => Promise<void> | void;
+      onError?: (err: unknown) => void;
+    };
+    replyOptions?: {
+      disableBlockStreaming?: boolean;
+      shouldEmitToolResult?: () => boolean;
+    };
+  },
+): Promise<unknown> {
+  const reply = resolveReplyApi(api);
+  if (typeof reply.dispatchReplyWithBufferedBlockDispatcher !== 'function') {
+    throw new Error('OpenClaw channel reply dispatchReplyWithBufferedBlockDispatcher API is unavailable');
+  }
+  return reply.dispatchReplyWithBufferedBlockDispatcher(params);
+}

package/src/openclaw/routing-runtime.ts

@@ -0,0 +1,48 @@
+import { resolveInboundLastRouteSessionKey } from 'openclaw/plugin-sdk/routing';
+
+type RuntimeRoutingApi = {
+  resolveAgentRoute?: (params: {
+    cfg: any;
+    channel: string;
+    accountId: string;
+    peer: unknown;
+  }) => any;
+};
+
+type RuntimeApiHolder = {
+  runtime?: {
+    channel?: {
+      routing?: RuntimeRoutingApi;
+    };
+  };
+};
+
+function resolveRoutingApi(api: RuntimeApiHolder): RuntimeRoutingApi {
+  const routing = api?.runtime?.channel?.routing;
+  if (!routing) throw new Error('OpenClaw channel routing API is unavailable');
+  return routing;
+}
+
+export function resolveOpenClawAgentRoute(
+  api: RuntimeApiHolder,
+  params: {
+    cfg: any;
+    channel: string;
+    accountId: string;
+    peer: unknown;
+  },
+): any {
+  const routing = resolveRoutingApi(api);
+  if (typeof routing.resolveAgentRoute !== 'function') {
+    throw new Error('OpenClaw channel routing resolveAgentRoute API is unavailable');
+  }
+  return routing.resolveAgentRoute(params);
+}
+
+export function resolveOpenClawInboundLastRouteSessionKey(params: {
+  route: unknown;
+  sessionKey: string;
+}): string {
+  return resolveInboundLastRouteSessionKey(params as any);
+}
+

package/src/openclaw/sdk-helpers.ts

@@ -0,0 +1,20 @@
+import { readBooleanParam as sdkReadBooleanParam } from 'openclaw/plugin-sdk/boolean-param';
+import {
+  applyAccountNameToChannelSection as sdkApplyAccountNameToChannelSection,
+  jsonResult as sdkJsonResult,
+  setAccountEnabledInConfigSection as sdkSetAccountEnabledInConfigSection,
+} from 'openclaw/plugin-sdk/core';
+import { readJsonFileWithFallback as sdkReadJsonFileWithFallback, writeJsonFileAtomically as sdkWriteJsonFileAtomically } from 'openclaw/plugin-sdk/json-store';
+import { readStringParam as sdkReadStringParam } from 'openclaw/plugin-sdk/param-readers';
+import { createDefaultChannelRuntimeState as sdkCreateDefaultChannelRuntimeState } from 'openclaw/plugin-sdk/status-helpers';
+import { extractToolSend as sdkExtractToolSend } from 'openclaw/plugin-sdk/tool-send';
+
+export const readOpenClawBooleanParam = sdkReadBooleanParam;
+export const readOpenClawStringParam = sdkReadStringParam;
+export const readOpenClawJsonFileWithFallback = sdkReadJsonFileWithFallback;
+export const writeOpenClawJsonFileAtomically = sdkWriteJsonFileAtomically;
+export const createOpenClawDefaultChannelRuntimeState = sdkCreateDefaultChannelRuntimeState;
+export const extractOpenClawToolSend = sdkExtractToolSend;
+export const openClawJsonResult = sdkJsonResult;
+export const applyOpenClawAccountNameToChannelSection = sdkApplyAccountNameToChannelSection;
+export const setOpenClawAccountEnabledInConfigSection = sdkSetAccountEnabledInConfigSection;

package/src/openclaw/session-route-runtime.ts

@@ -0,0 +1,15 @@
+import { buildChannelOutboundSessionRoute } from 'openclaw/plugin-sdk/core';
+
+export function buildOpenClawChannelOutboundSessionRoute(params: {
+  cfg: any;
+  agentId: string;
+  channel: string;
+  accountId?: string;
+  peer: unknown;
+  chatType: 'direct' | 'group';
+  from: string;
+  to: string;
+  threadId?: string;
+}): Record<string, unknown> {
+  return buildChannelOutboundSessionRoute(params as any) as Record<string, unknown>;
+}