import type { AcpRuntimeSessionMode } from "../acp/runtime/types.js";

import { DEFAULT_HEARTBEAT_EVERY } from "../auto-reply/heartbeat.js";

import {

getChannelPlugin,

getLoadedChannelPlugin,

normalizeChannelId,

} from "../channels/plugins/index.js";

import {

resolveBundledChannelThreadBindingDefaultPlacement,

resolveBundledChannelThreadBindingInboundConversation,

} from "../channels/plugins/thread-binding-api.js";

resolveChannelDefaultBindingPlacement,

resolveInboundConversationResolution,

} from "../channels/conversation-resolution.js";

import {

resolveThreadBindingIntroText,

resolveThreadBindingThreadName,

import type { OpenClawConfig } from "../config/types.openclaw.js";

import { callGateway } from "../gateway/call.js";

import { areHeartbeatsEnabled } from "../infra/heartbeat-wake.js";

import { resolveConversationIdFromTargets } from "../infra/outbound/conversation-id.js";

import { normalizeConversationTargetRef } from "../infra/outbound/session-binding-normalization.js";

import {

getSessionBindingService,

isSessionBindingError,

return params.capabilities.placements.includes("child") ? "child" : "current";

}

function resolvePluginConversationRefForThreadBinding(params: {

channelId: string;

to?: string;

threadId?: string | number;

groupId?: string;

}): { conversationId: string; parentConversationId?: string } | null {

const resolverParams = {

// Keep the live delivery target authoritative; conversationId is only a fallback hint.

to: params.to,

conversationId: params.groupId ?? params.to,

threadId: params.threadId,

isGroup: true,

};

const loadedPluginConversation = getLoadedChannelPlugin(

params.channelId,

)?.messaging?.resolveInboundConversation?.(resolverParams);

const bundledApiConversation =

loadedPluginConversation === undefined

? resolveBundledChannelThreadBindingInboundConversation({

channelId: params.channelId,

...resolverParams,

})

: undefined;

const resolvedConversation =

loadedPluginConversation ??

(bundledApiConversation !== undefined

? bundledApiConversation

: getChannelPlugin(params.channelId)?.messaging?.resolveInboundConversation?.(

resolverParams,

));

const conversationId = normalizeOptionalString(resolvedConversation?.conversationId);

if (!conversationId) {

return null;

}

return normalizeConversationTargetRef({

conversationId,

parentConversationId: resolvedConversation?.parentConversationId,

});

}

function resolveSpawnMode(params: {

requestedMode?: SpawnAcpMode;

threadRequested: boolean;

}

function resolveConversationRefForThreadBinding(params: {

cfg: OpenClawConfig;

channel?: string;

accountId?: string;

to?: string;

threadId?: string | number;

groupId?: string;

}): { conversationId: string; parentConversationId?: string } | null {

const channel = normalizeOptionalLowercaseString(params.channel);

const normalizedChannelId = channel ? normalizeChannelId(channel) : null;

const pluginResolvedConversation = normalizedChannelId

? resolvePluginConversationRefForThreadBinding({

channelId: normalizedChannelId,

to: params.to,

threadId: params.threadId,

groupId: params.groupId,

})

: null;

if (pluginResolvedConversation) {

return pluginResolvedConversation;

}

const parentConversationId = resolveConversationIdFromTargets({

targets: [params.to],

});

const genericConversationId = resolveConversationIdFromTargets({

const resolution = resolveInboundConversationResolution({

cfg: params.cfg,

channel: params.channel,

accountId: params.accountId,

to: params.to,

threadId: params.threadId,

targets: [params.to],

groupId: params.groupId,

isGroup: true,

});

if (genericConversationId) {

return normalizeConversationTargetRef({

conversationId: genericConversationId,

parentConversationId: params.threadId != null ? parentConversationId : undefined,

});

}

return null;

return resolution?.canonical ?? null;

}

function resolveAcpSpawnChannelAccountId(params: {

error: `Thread bindings are unavailable for ${policy.channel}.`,

};

}

const loadedPluginPlacement = getLoadedChannelPlugin(policy.channel)?.conversationBindings

?.defaultTopLevelPlacement;

const bundledApiPlacement =

loadedPluginPlacement ?? resolveBundledChannelThreadBindingDefaultPlacement(policy.channel);

const pluginPlacement =

bundledApiPlacement ??

getChannelPlugin(policy.channel)?.conversationBindings?.defaultTopLevelPlacement;

const pluginPlacement = resolveChannelDefaultBindingPlacement(policy.channel);

const placementToUse =

pluginPlacement ??

resolvePlacementWithoutChannelPlugin({

};

}

const conversationRef = resolveConversationRefForThreadBinding({

cfg: params.cfg,

channel: policy.channel,

accountId: policy.accountId,

to: params.to,

threadId: params.threadId,

groupId: params.groupId,

fallbackThreadIdRaw != null ? normalizeOptionalString(String(fallbackThreadIdRaw)) : undefined;

const deliveryThreadId = boundThreadId ?? fallbackThreadId;

const requesterConversationRef = resolveConversationRefForThreadBinding({

cfg: params.cfg,

channel: params.requester.origin?.channel,

accountId: params.requester.origin?.accountId,

threadId: fallbackThreadId,

to: params.requester.origin?.to,

});