if (!handle) {

return null;

}

const account = resolveIMessageAccount({ cfg: params.cfg, accountId: params.accountId });

const service =

parsed.serviceExplicit || parsed.service !== "auto"

? parsed.service

: account.config.service === "sms"

? "sms"

: "imessage";

const directTarget = `${service}:${handle}`;

const peer: RoutePeer = { kind: "direct", id: handle };

const baseSessionKey = buildIMessageBaseSessionKey({

cfg: params.cfg,

baseSessionKey,

peer,

chatType: "direct" as const,

from: `imessage:${handle}`,

to: `imessage:${handle}`,

from: directTarget,

to: directTarget,

};

}

import { uniqueStrings } from "openclaw/plugin-sdk/string-coerce-runtime";

import { sanitizeTerminalText } from "openclaw/plugin-sdk/text-chunking";

import { truncateUtf16Safe } from "openclaw/plugin-sdk/text-utility-runtime";

import { resolveIMessageAccount } from "../accounts.js";

import { resolveIMessageConversationRoute } from "../conversation-route.js";

import {

isKnownFromMeIMessageMessageId,

});

}

const imessageTo = (decision.isGroup ? chatTarget : undefined) || `imessage:${decision.sender}`;

const imessageTo = decision.isGroup

? chatTarget || `imessage:${decision.sender}`

: buildDirectIMessageReplyTarget({

cfg: params.cfg,

accountId: decision.route.accountId,

sender: decision.sender,

});

// Async follow-ups can resume from the stored origin instead of the immediate

// reply target. Keep direct SMS origins service-qualified the same way as To,

// or the final resumed message can fall back to imessage:<phone>.

const imessageFrom = decision.isGroup ? `imessage:group:${chatId ?? "unknown"}` : imessageTo;

const inboundHistory =

!decision.isGroup && params.dmHistory?.inboundHistory

? params.dmHistory.inboundHistory

messageId: messageSid,

messageIdFull: messageGuid,

timestamp: decision.createdAt,

from: decision.isGroup

? `imessage:group:${chatId ?? "unknown"}`

: `imessage:${decision.sender}`,

from: imessageFrom,

sender: {

id: decision.sender,

name: decision.senderNormalized,

return scopes;

}

function buildDirectIMessageReplyTarget(params: {

cfg: OpenClawConfig;

accountId?: string | null;

sender: string;

}): string {

const account = resolveIMessageAccount({ cfg: params.cfg, accountId: params.accountId });

const configuredService = account.config.service;

if (configuredService === "sms") {

return `sms:${params.sender}`;

}

return `imessage:${params.sender}`;

}

export function describeIMessageEchoDropLog(params: {

messageText: string;

messageId?: string;

logVerbose,

})

: undefined;

const { ctxPayload, chatTarget } = await buildIMessageInboundContext({

const { ctxPayload, chatTarget, imessageTo } = await buildIMessageInboundContext({

cfg,

decision,

message,

},

});

const updateTarget = chatTarget || decision.sender;

const updateTarget = chatTarget || imessageTo;

const pinnedMainDmOwner = resolvePinnedMainDmOwnerFromAllowlist({

dmScope: cfg.session?.dmScope,

allowFrom,

return typeof value === "string" && /^\d+$/.test(value.trim());

}

function resolveTargetService(target: ParsedIMessageTarget): IMessageService | undefined {

if (target.kind !== "handle") {

return undefined;

}

if (target.serviceExplicit || target.service !== "auto") {

return target.service;

}

return undefined;

}

function normalizeResolvedMessageGuid(value: unknown): string | null {

if (typeof value !== "string") {

return null;

const target = parseIMessageTarget(opts.chatId ? formatIMessageChatTarget(opts.chatId) : to);

const service =

opts.service ??

(target.kind === "handle" ? target.service : undefined) ??

resolveTargetService(target) ??

(account.config.service as IMessageService | undefined);

const timeoutMs = opts.timeoutMs ?? account.config.probeTimeoutMs;

const region = opts.region?.trim() || account.config.region?.trim() || "US";

const maxBytes =

typeof opts.maxBytes === "number"

const resolvedReplyToId = sanitizeReplyToId(opts.replyToId);

const runCliJson =

opts.runCliJson ??

((args: readonly string[]) => runIMessageCliJson(cliPath, dbPath, args, opts.timeoutMs));

((args: readonly string[]) => runIMessageCliJson(cliPath, dbPath, args, timeoutMs));

if (filePath && !message.trim() && !resolvedReplyToId) {

const attachmentResult = await trySendAttachmentForExplicitChat({

try {

try {

result = await client.request<Record<string, unknown>>("send", params, {

timeoutMs: opts.timeoutMs,

timeoutMs,

});

} catch (error) {

if (filePath || resolvedReplyToId || !isIMessageRpcSendTimeout(error)) {

| { kind: "chat_id"; chatId: number }

| { kind: "chat_guid"; chatGuid: string }

| { kind: "chat_identifier"; chatIdentifier: string }

| { kind: "handle"; to: string; service: IMessageService };

| { kind: "handle"; to: string; service: IMessageService; serviceExplicit?: boolean };

export type IMessageAllowTarget = ParsedChatTarget | { kind: "handle"; handle: string };

parseTarget: parseIMessageTarget,

});

if (servicePrefixed) {

if (servicePrefixed.kind === "handle") {

return { ...servicePrefixed, serviceExplicit: true };

}

return servicePrefixed;

}