@xmoxmo/bncr 0.3.5 → 0.3.7

package/src/messaging/inbound/media-url-download.ts

@@ -0,0 +1,109 @@
+export const INBOUND_MEDIA_URL_MAX_BYTES = 200 * 1024 * 1024;
+const INBOUND_MEDIA_URL_TIMEOUT_MS = 30_000;
+
+export function isHttpMediaUrl(value: string): boolean {
+  try {
+    const parsed = new URL(value);
+    return parsed.protocol === 'http:' || parsed.protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+function readResponseHeader(headers: unknown, name: string): string | undefined {
+  if (!headers || typeof (headers as { get?: unknown }).get !== 'function') return undefined;
+  const value = (headers as { get(name: string): string | null }).get(name);
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function normalizeInboundMediaUrlTimeoutMs(timeoutMs: number): number {
+  return Number.isFinite(timeoutMs) && timeoutMs > 0
+    ? Math.floor(timeoutMs)
+    : INBOUND_MEDIA_URL_TIMEOUT_MS;
+}
+
+async function readInboundMediaResponseBody(args: {
+  response: Response;
+  maxBytes: number;
+  abort: () => void;
+}): Promise<Buffer> {
+  const body = args.response.body;
+  if (!body || typeof body.getReader !== 'function') {
+    const buffer = Buffer.from(await args.response.arrayBuffer());
+    if (buffer.length > args.maxBytes) {
+      throw new Error(
+        `inbound media url too large: ${buffer.length} bytes exceeds ${args.maxBytes} bytes`,
+      );
+    }
+    return buffer;
+  }
+
+  const reader = body.getReader();
+  const chunks: Buffer[] = [];
+  let total = 0;
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      const chunk = Buffer.from(value);
+      total += chunk.byteLength;
+      if (total > args.maxBytes) {
+        args.abort();
+        throw new Error(
+          `inbound media url too large: ${total} bytes exceeds ${args.maxBytes} bytes`,
+        );
+      }
+      chunks.push(chunk);
+    }
+  } finally {
+    reader.releaseLock();
+  }
+  return Buffer.concat(chunks, total);
+}
+
+export async function downloadInboundMediaUrl(
+  url: string,
+  maxBytes = INBOUND_MEDIA_URL_MAX_BYTES,
+  timeoutMs = INBOUND_MEDIA_URL_TIMEOUT_MS,
+): Promise<{ buffer: Buffer; contentType?: string }> {
+  if (typeof fetch !== 'function') {
+    throw new Error('inbound media url download unavailable: fetch is not available');
+  }
+
+  const abortController = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => {
+    timedOut = true;
+    abortController.abort();
+  }, normalizeInboundMediaUrlTimeoutMs(timeoutMs));
+
+  try {
+    const response = await fetch(url, { signal: abortController.signal });
+    if (!response.ok) {
+      throw new Error(`inbound media url download failed: HTTP ${response.status}`);
+    }
+
+    const contentLength = Number(readResponseHeader(response.headers, 'content-length') || 0);
+    if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+      abortController.abort();
+      throw new Error(
+        `inbound media url too large: content-length ${contentLength} bytes exceeds ${maxBytes} bytes`,
+      );
+    }
+
+    const buffer = await readInboundMediaResponseBody({
+      response,
+      maxBytes,
+      abort: () => abortController.abort(),
+    });
+    if (!buffer.length) throw new Error('inbound media url downloaded empty buffer');
+
+    return { buffer, contentType: readResponseHeader(response.headers, 'content-type') };
+  } catch (err) {
+    if (timedOut) throw new Error(`inbound media url download timed out after ${timeoutMs}ms`);
+    throw err;
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/src/messaging/inbound/native-command-runtime.ts

@@ -0,0 +1,225 @@
+import { emitBncrLogLine } from '../../core/logging.ts';
+import {
+  formatDisplayScope,
+  normalizeInboundSessionKey,
+  withTaskSessionKey,
+} from '../../core/targets.ts';
+import type {
+  BncrEnqueueFromReply,
+  BncrInboundApi,
+  BncrInboundConfig,
+  BncrInboundContextPayload,
+} from './contracts.ts';
+import type { ParsedInbound } from './dispatch-prep.ts';
+import { buildBncrNativeReplyDeliveryPayload } from './native-reply-delivery.ts';
+import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
+
+export function logBncrNativeCommandEvent(
+  event: string,
+  fields: Record<string, unknown>,
+  options?: { debugOnly?: boolean; debugEnabled?: boolean },
+) {
+  if (options?.debugOnly && !options?.debugEnabled) return;
+  emitBncrLogLine('info', `[bncr] native-command ${JSON.stringify({ event, ...fields })}`);
+}
+
+export function logBncrNativeCommandSummary(message: string) {
+  emitBncrLogLine('info', `[bncr] native-command ${String(message || '').trim()}`);
+}
+
+export function buildBncrNativeCommandSummary(args: {
+  kind: string;
+  command: string;
+  accountId: string;
+  to: string;
+  msgId?: string | null;
+  result: string;
+}) {
+  return `${args.kind} command=${args.command}|accountId=${args.accountId}|to=${args.to}|msgId=${args.msgId || '-'}|result=${args.result}`;
+}
+
+export function buildNativeCommandHandledResult(args: {
+  command: string;
+  sessionKey: string;
+  fallbackToAgent?: boolean;
+}) {
+  return {
+    handled: true as const,
+    command: args.command,
+    sessionKey: args.sessionKey,
+    ...(args.fallbackToAgent ? { fallbackToAgent: true } : {}),
+  };
+}
+
+export function buildBncrNativeCommandSessionState(args: {
+  parsed: ParsedInbound;
+  canonicalAgentId: string;
+  resolvedRoute: { sessionKey: string };
+}) {
+  const { parsed, canonicalAgentId, resolvedRoute } = args;
+  const baseSessionKey =
+    normalizeInboundSessionKey(parsed.sessionKeyfromroute, parsed.route, canonicalAgentId) ||
+    resolvedRoute.sessionKey;
+  const taskSessionKey = withTaskSessionKey(baseSessionKey, parsed.extracted.taskKey);
+  const sessionKey = taskSessionKey || baseSessionKey;
+  const displayTo = formatDisplayScope(parsed.route);
+  const originatingTo = parsed.providedOriginatingTo || displayTo;
+  return {
+    baseSessionKey,
+    taskSessionKey,
+    sessionKey,
+    displayTo,
+    originatingTo,
+  };
+}
+
+export function createNativeCommandTurnContext(args: {
+  api: BncrInboundApi;
+  channelId: string;
+  accountId: string;
+  msgId?: string;
+  peer: ParsedInbound['peer'];
+  resolvedRoute: { sessionKey: string; agentId: string; mainSessionKey?: string };
+  sessionKey: string;
+  displayTo: string;
+  originatingTo: string;
+  senderIdForContext: string;
+  senderDisplayName: string;
+  body: string;
+}): BncrInboundContextPayload | Promise<BncrInboundContextPayload> {
+  return resolveBncrChannelInboundRuntime(args.api).buildContext({
+    channel: args.channelId,
+    provider: args.channelId,
+    surface: args.channelId,
+    accountId: args.accountId,
+    messageId: args.msgId,
+    timestamp: Date.now(),
+    from: args.senderIdForContext,
+    sender: {
+      id: args.senderIdForContext,
+      name: args.senderDisplayName,
+      username: args.senderDisplayName,
+    },
+    conversation: {
+      kind: args.peer.kind,
+      id: args.peer.id,
+      label: args.displayTo,
+      routePeer: {
+        kind: args.peer.kind,
+        id: args.peer.id,
+      },
+    },
+    route: {
+      agentId: args.resolvedRoute.agentId,
+      accountId: args.accountId,
+      routeSessionKey: args.resolvedRoute.sessionKey,
+      dispatchSessionKey: args.sessionKey,
+      mainSessionKey: args.resolvedRoute.mainSessionKey,
+    },
+    reply: {
+      to: args.displayTo,
+      originatingTo: args.originatingTo,
+      replyToId: args.msgId,
+    },
+    message: {
+      inboundEventKind: 'user_request',
+      body: args.body,
+      rawBody: args.body,
+      bodyForAgent: args.body,
+      commandBody: args.body,
+      envelopeFrom: args.originatingTo,
+      senderLabel: args.senderDisplayName,
+    },
+    commandTurn: {
+      kind: 'native',
+      source: 'native',
+      authorized: true,
+      body: args.body,
+    },
+    access: {
+      mentions: {
+        canDetectMention: true,
+        wasMentioned: true,
+        effectiveWasMentioned: true,
+      },
+      commands: {
+        authorized: true,
+        allowTextCommands: true,
+        useAccessGroups: false,
+        authorizers: [],
+      },
+    },
+    extra: {
+      OriginatingChannel: args.channelId,
+    },
+  });
+}
+
+export function createNativeCommandReplyDeliverer(args: {
+  command: string;
+  accountId: string;
+  sessionKey: string;
+  to: string;
+  msgId?: string;
+  effectiveReply: { blockStreaming: boolean; allowTool: boolean };
+  route: ParsedInbound['route'];
+  enqueueFromReply: BncrEnqueueFromReply;
+  nativeCommandDebugEnabled: boolean;
+  onResponded: () => boolean;
+  markResponded: () => void;
+}) {
+  return async (
+    payload: {
+      text?: string;
+      mediaUrl?: string;
+      mediaUrls?: string[];
+      audioAsVoice?: boolean;
+    },
+    info?: { kind?: 'tool' | 'block' | 'final' },
+  ) => {
+    const kind = info?.kind;
+    const deliveryPayload = buildBncrNativeReplyDeliveryPayload({
+      payload,
+      kind,
+      effectiveReply: args.effectiveReply,
+      msgId: args.msgId,
+    });
+    if (!deliveryPayload) return;
+
+    if (!args.onResponded()) {
+      logBncrNativeCommandEvent(
+        'payload-produced',
+        {
+          command: args.command,
+          accountId: args.accountId,
+          sessionKey: args.sessionKey,
+          to: args.to,
+          msgId: args.msgId || null,
+          kind: kind || null,
+          fallbackToAgent: false,
+        },
+        { debugOnly: true, debugEnabled: args.nativeCommandDebugEnabled },
+      );
+    }
+
+    args.markResponded();
+    await args.enqueueFromReply({
+      accountId: args.accountId,
+      sessionKey: args.sessionKey,
+      route: args.route,
+      payload: deliveryPayload,
+      replyTargetPolicy: 'preserve',
+    });
+  };
+}
+
+export function buildNativeCommandRecordErrorLogger(err: unknown) {
+  emitBncrLogLine('warn', `[bncr] inbound record native command session failed: ${String(err)}`);
+}
+
+export function resolveNativeCommandDebugEnabled(args: {
+  cfg: BncrInboundConfig;
+  channelId: string;
+}) {
+  return args.cfg?.channels?.[args.channelId]?.debug?.verbose === true;
+}

package/src/messaging/inbound/parse.ts

@@ -2,6 +2,7 @@ import { createHash } from 'node:crypto';
 import { normalizeAccountId } from '../../core/accounts.ts';
 import { extractInlineTaskKey } from '../../core/targets.ts';
 import type { BncrRoute } from '../../core/types.ts';
+import type { BncrInboundParamsInput } from './contracts.ts';
 
 function asString(v: unknown, fallback = ''): string {
   if (typeof v === 'string') return v;
@@ -43,7 +44,7 @@ export function resolveChatType(_route: BncrRoute): 'direct' | 'group' {
   return 'direct';
 }
 
-export function parseBncrInboundParams(params: any) {
+export function parseBncrInboundParams(params: BncrInboundParamsInput) {
   const accountId = normalizeAccountId(asString(params?.accountId || ''));
   const platform = asString(params?.platform || '').trim();
   const groupId = asString(params?.groupId || '0').trim() || '0';

package/src/messaging/inbound/remote-media.ts

@@ -0,0 +1,49 @@
+import type { OpenClawLoadedMedia } from '../../openclaw/media-runtime.ts';
+import { downloadInboundMediaUrl, INBOUND_MEDIA_URL_MAX_BYTES } from './media-url-download.ts';
+
+type RuntimeChannelMediaReader = {
+  runtime?: {
+    channel?: {
+      media?: {
+        readRemoteMediaBuffer?: (options: {
+          url: string;
+          maxBytes?: number;
+        }) => Promise<OpenClawLoadedMedia>;
+      };
+    };
+  };
+};
+
+function assertLoadedInboundRemoteMedia(
+  loaded: OpenClawLoadedMedia,
+  source: 'runtime' | 'fallback',
+): OpenClawLoadedMedia {
+  if (!loaded?.buffer?.length) {
+    throw new Error(`inbound remote media ${source} download returned empty buffer`);
+  }
+  return loaded;
+}
+
+async function readRemoteMediaBufferFromRuntime(
+  api: RuntimeChannelMediaReader,
+  url: string,
+  maxBytes: number,
+): Promise<OpenClawLoadedMedia> {
+  const readRemoteMediaBuffer = api?.runtime?.channel?.media?.readRemoteMediaBuffer;
+  if (typeof readRemoteMediaBuffer !== 'function') {
+    throw new Error('OpenClaw channel media readRemoteMediaBuffer API is unavailable');
+  }
+  return assertLoadedInboundRemoteMedia(await readRemoteMediaBuffer({ url, maxBytes }), 'runtime');
+}
+
+export async function loadInboundRemoteMedia(
+  api: RuntimeChannelMediaReader,
+  url: string,
+  maxBytes = INBOUND_MEDIA_URL_MAX_BYTES,
+): Promise<OpenClawLoadedMedia> {
+  try {
+    return await readRemoteMediaBufferFromRuntime(api, url, maxBytes);
+  } catch {
+    return assertLoadedInboundRemoteMedia(await downloadInboundMediaUrl(url, maxBytes), 'fallback');
+  }
+}

package/src/messaging/inbound/reply-config.ts

@@ -1,7 +1,9 @@
+import type { BncrInboundConfig } from './contracts.ts';
+
 type BncrReplyConfigResult = {
   blockStreaming: boolean;
   allowTool: boolean;
-  replyCfg: any;
+  replyCfg: BncrInboundConfig;
 };
 
 function parseBooleanLike(value: unknown): boolean | undefined {
@@ -20,7 +22,7 @@ function parseBooleanLike(value: unknown): boolean | undefined {
   return undefined;
 }
 
-export function resolveBncrBlockStreaming(cfg: any): boolean {
+export function resolveBncrBlockStreaming(cfg: BncrInboundConfig): boolean {
   const channelValue = parseBooleanLike(cfg?.channels?.bncr?.blockStreaming);
   if (channelValue !== undefined) return channelValue;
 
@@ -30,11 +32,11 @@ export function resolveBncrBlockStreaming(cfg: any): boolean {
   return true;
 }
 
-export function resolveBncrAllowTool(cfg: any): boolean {
+export function resolveBncrAllowTool(cfg: BncrInboundConfig): boolean {
   return cfg?.channels?.bncr?.allowTool === true;
 }
 
-export function buildBncrReplyConfig(cfg: any): BncrReplyConfigResult {
+export function buildBncrReplyConfig(cfg: BncrInboundConfig): BncrReplyConfigResult {
   const blockStreaming = resolveBncrBlockStreaming(cfg);
   const allowTool = resolveBncrAllowTool(cfg);
 
@@ -46,6 +48,16 @@ export function buildBncrReplyConfig(cfg: any): BncrReplyConfigResult {
         ...(cfg?.agents?.defaults ?? {}),
       },
     },
+  } as BncrInboundConfig & {
+    agents: {
+      defaults: {
+        blockStreamingBreak?: string;
+        blockStreamingChunk?: { minChars: number; maxChars: number };
+        blockStreamingDefault?: unknown;
+        [key: string]: unknown;
+      };
+      [key: string]: unknown;
+    };
   };
 
   if (replyCfg.agents.defaults.blockStreamingBreak == null) {

package/src/messaging/inbound/reply-dispatch.ts

@@ -0,0 +1,162 @@
+import { emitBncrLogLine } from '../../core/logging.ts';
+import { resolveBncrChannelPolicy } from '../../core/policy.ts';
+import {
+  recordBncrInboundSession,
+  resolveBncrPinnedMainDmOwnerFromAllowlist,
+} from '../../openclaw/inbound-session-runtime.ts';
+import { dispatchOpenClawReplyWithBufferedBlockDispatcher } from '../../openclaw/reply-runtime.ts';
+import type {
+  BncrEnqueueFromReply,
+  BncrInboundApi,
+  BncrInboundConfig,
+  BncrInboundContextPayload,
+} from './contracts.ts';
+import type {
+  BncrInboundConversationResolution,
+  BncrInboundReplyRouteFact,
+  ParsedInbound,
+} from './dispatch-prep.ts';
+import { buildBncrInboundRecordUpdateLastRoute } from './last-route.ts';
+import { buildBncrReplyConfig } from './reply-config.ts';
+import { resolveBncrChannelInboundRuntime } from './runtime-compat.ts';
+import { wrapBncrInboundRecordSessionLabelCorrection } from './session-label.ts';
+
+export async function runBncrInboundReplyDispatch(args: {
+  api: BncrInboundApi;
+  channelId: string;
+  cfg: BncrInboundConfig;
+  parsed: ParsedInbound;
+  msgId?: string | null;
+  peer: ParsedInbound['peer'];
+  rawBody: string;
+  storePath: string;
+  ctxPayload: BncrInboundContextPayload;
+  resolution: BncrInboundConversationResolution;
+  replyRouteFact: BncrInboundReplyRouteFact;
+  senderIdForContext: string;
+  setInboundActivity: (accountId: string, at: number) => void;
+  scheduleSave: () => void;
+  enqueueFromReply: BncrEnqueueFromReply;
+}) {
+  const {
+    api,
+    channelId,
+    cfg,
+    parsed,
+    msgId,
+    peer,
+    rawBody,
+    storePath,
+    ctxPayload,
+    resolution,
+    replyRouteFact,
+    senderIdForContext,
+    setInboundActivity,
+    scheduleSave,
+    enqueueFromReply,
+  } = args;
+
+  const effectiveReply = buildBncrReplyConfig(cfg);
+  const channelPolicy = resolveBncrChannelPolicy(cfg?.channels?.bncr || {});
+  const pinnedMainDmOwner =
+    peer.kind === 'direct'
+      ? resolveBncrPinnedMainDmOwnerFromAllowlist({
+          dmScope: cfg?.session?.dmScope as string | undefined,
+          allowFrom: channelPolicy.allowFrom,
+          normalizeEntry: (entry: string) => String(entry || '').trim(),
+        })
+      : null;
+  const updateLastRoute = buildBncrInboundRecordUpdateLastRoute({
+    channelId,
+    peerKind: peer.kind,
+    senderIdForContext,
+    accountId: resolution.accountId,
+    to: resolution.canonicalTo,
+    resolvedRoute: resolution.resolvedRoute,
+    sessionKey: resolution.dispatchSessionKey,
+    pinnedMainDmOwner,
+  });
+
+  await resolveBncrChannelInboundRuntime(api).run({
+    channel: channelId,
+    accountId: resolution.accountId,
+    raw: parsed,
+    adapter: {
+      ingest: () => ({
+        id: msgId ?? `${resolution.canonicalTo}:${Date.now()}`,
+        timestamp: Date.now(),
+        rawText: rawBody,
+        textForAgent: ctxPayload.BodyForAgent,
+        textForCommands: ctxPayload.CommandBody,
+        raw: parsed,
+      }),
+      resolveTurn: () => ({
+        channel: channelId,
+        accountId: resolution.accountId,
+        routeSessionKey: resolution.resolvedRoute.sessionKey,
+        storePath,
+        ctxPayload,
+        recordInboundSession: wrapBncrInboundRecordSessionLabelCorrection({
+          recordInboundSession: recordBncrInboundSession as (
+            ...args: unknown[]
+          ) => Promise<unknown> | unknown,
+          expectedLabel: resolution.canonicalTo,
+        }),
+        record: {
+          updateLastRoute,
+          onRecordError: (err: unknown) => {
+            emitBncrLogLine('warn', `[bncr] inbound record session failed: ${String(err)}`);
+          },
+        },
+        runDispatch: () =>
+          dispatchOpenClawReplyWithBufferedBlockDispatcher(api, {
+            ctx: ctxPayload,
+            cfg: effectiveReply.replyCfg,
+            dispatcherOptions: {
+              deliver: async (
+                payload: {
+                  text?: string;
+                  mediaUrl?: string;
+                  mediaUrls?: string[];
+                  audioAsVoice?: boolean;
+                },
+                info?: { kind?: 'tool' | 'block' | 'final' },
+              ) => {
+                const kind = info?.kind;
+                const shouldForwardTool = effectiveReply.blockStreaming && effectiveReply.allowTool;
+
+                if (kind === 'tool' && !shouldForwardTool) {
+                  return;
+                }
+
+                await enqueueFromReply({
+                  accountId: replyRouteFact.accountId,
+                  sessionKey: replyRouteFact.sessionKey,
+                  route: replyRouteFact.route,
+                  payload: {
+                    text: payload.text,
+                    mediaUrl: payload.mediaUrl,
+                    mediaUrls: payload.mediaUrls,
+                    kind: kind || 'final',
+                    replyToId: msgId || undefined,
+                  },
+                });
+              },
+              onError: (err: unknown) => {
+                emitBncrLogLine('error', `[bncr] outbound reply failed: ${String(err)}`);
+              },
+            },
+            replyOptions: {
+              disableBlockStreaming: !effectiveReply.blockStreaming,
+              shouldEmitToolResult: effectiveReply.allowTool ? () => true : undefined,
+            },
+          }),
+      }),
+      onFinalize: () => {
+        const inboundAt = Date.now();
+        setInboundActivity(resolution.accountId, inboundAt);
+        scheduleSave();
+      },
+    },
+  });
+}

package/src/messaging/inbound/runtime-compat.ts

@@ -1,19 +1,40 @@
 import { emitBncrLogLine } from '../../core/logging.ts';
+import type { OpenClawInboundRuntime } from '../../openclaw/channel-runtime-contracts.ts';
+import type { BncrInboundApi } from './contracts.ts';
 
-type ChannelRuntimeCompat = {
-  buildContext: (...args: any[]) => any;
-  run: (...args: any[]) => Promise<any> | any;
-  runPreparedReply?: (...args: any[]) => Promise<any> | any;
-  dispatchReply?: (...args: any[]) => Promise<any> | any;
+type InboundRuntimeShape = {
+  buildContext?: (params: unknown) => unknown;
+  run?: (params: unknown) => unknown;
+  runPreparedReply?: (params: unknown) => unknown;
+  dispatchReply?: (params: unknown) => unknown;
+};
+
+type LegacyTurnRuntimeShape = {
+  buildContext?: (params: unknown) => unknown;
+  run?: (params: unknown) => unknown;
+  runPrepared?: (params: unknown) => unknown;
+  dispatchAssembled?: (params: unknown) => unknown;
+  runAssembled?: (params: unknown) => unknown;
+};
+
+type ChannelRuntimeShape = {
+  inbound?: InboundRuntimeShape;
+  turn?: LegacyTurnRuntimeShape;
+  [key: string]: unknown;
 };
 
 let warnedLegacyTurnRuntime = false;
 
-export function resolveBncrChannelInboundRuntime(api: any): ChannelRuntimeCompat {
-  const channelRuntime = api?.runtime?.channel;
+export function resolveBncrChannelInboundRuntime(api: BncrInboundApi): OpenClawInboundRuntime {
+  const channelRuntime = api?.runtime?.channel as ChannelRuntimeShape | undefined;
   const inboundRuntime = channelRuntime?.inbound;
   if (inboundRuntime?.buildContext && inboundRuntime?.run) {
-    return inboundRuntime;
+    return {
+      buildContext: inboundRuntime.buildContext as OpenClawInboundRuntime['buildContext'],
+      run: inboundRuntime.run as OpenClawInboundRuntime['run'],
+      runPreparedReply: inboundRuntime.runPreparedReply,
+      dispatchReply: inboundRuntime.dispatchReply,
+    };
   }
 
   const legacyTurnRuntime = channelRuntime?.turn;
@@ -34,8 +55,8 @@ export function resolveBncrChannelInboundRuntime(api: any): ChannelRuntimeCompat
       );
     }
     return {
-      buildContext: legacyTurnRuntime.buildContext,
-      run: legacyTurnRuntime.run,
+      buildContext: legacyTurnRuntime.buildContext as OpenClawInboundRuntime['buildContext'],
+      run: legacyTurnRuntime.run as OpenClawInboundRuntime['run'],
       runPreparedReply: legacyTurnRuntime.runPrepared,
       dispatchReply: legacyTurnRuntime.dispatchAssembled ?? legacyTurnRuntime.runAssembled,
     };