@moltzap/openclaw-channel 2026.329.0 → 2026.413.0

package/dist/openclaw-entry.js

@@ -7,8 +7,9 @@
  * Installed via: openclaw plugin install @moltzap/openclaw-channel
  * Config:        channels.moltzap.accounts[].{apiKey, serverUrl, agentName}
  */
-import { MoltZapWsClient } from "./ws-client.js";
-import { extractMessage, extractReadReceipt, extractReaction, extractDelivery, extractDeletion, extractConversationCreated, extractConversationUpdated, extractContactRequest, extractContactAccepted, extractPresenceChanged, extractTypingIndicator, mapMessageToEnvelope, } from "./mapping.js";
+import { MoltZapChannelCore, MoltZapService, formatCrossConversationBlock, } from "@moltzap/client";
+import { extractReadReceipt, extractReaction, extractDelivery, extractDeletion, extractConversationCreated, extractConversationUpdated, extractContactRequest, extractContactAccepted, extractPresenceChanged, extractTypingIndicator, } from "./mapping.js";
+import { EventNames } from "@moltzap/protocol";
 const DEFAULT_ACCOUNT_ID = "default";
 const CHANNEL_ID = "moltzap";
 const TARGET_PREFIX_AGENT = "agent:";
@@ -30,8 +31,6 @@ function resolveAccount(cfg, accountId) {
         accounts[0] ?? { id, apiKey: "", serverUrl: "", agentName: "" });
 }
 const activeClients = new Map();
-/** Cache: accountId → (agentName → conversationId) for auto-created DM conversations. */
-export const agentConversationCache = new Map();
 export const moltzapChannelPlugin = {
     id: CHANNEL_ID,
     meta: {
@@ -73,17 +72,17 @@ export const moltzapChannelPlugin = {
     },
     directory: {
         async listPeers(params) {
-            const client = activeClients.get(params.accountId ?? DEFAULT_ACCOUNT_ID);
-            if (!client)
+            const service = activeClients.get(params.accountId ?? DEFAULT_ACCOUNT_ID);
+            if (!service)
                 return [];
             try {
-                const { contacts } = (await client.sendRpc("contacts/list", {
+                const { contacts } = (await service.sendRpc("contacts/list", {
                     status: "accepted",
                 }));
                 const agentIds = contacts.flatMap((c) => (c.agents ?? []).map((a) => a.id));
                 if (agentIds.length === 0)
                     return [];
-                const { agents } = (await client.sendRpc("agents/lookup", {
+                const { agents } = (await service.sendRpc("agents/lookup", {
                     agentIds,
                 }));
                 return agents.map((a) => ({
@@ -97,11 +96,11 @@ export const moltzapChannelPlugin = {
             }
         },
         async listGroups(params) {
-            const client = activeClients.get(params.accountId ?? DEFAULT_ACCOUNT_ID);
-            if (!client)
+            const service = activeClients.get(params.accountId ?? DEFAULT_ACCOUNT_ID);
+            if (!service)
                 return [];
             try {
-                const { conversations } = (await client.sendRpc("conversations/list", {}));
+                const { conversations } = (await service.sendRpc("conversations/list", {}));
                 return conversations
                     .filter((c) => c.type === "group" && c.name)
                     .map((c) => ({
@@ -143,332 +142,209 @@ export const moltzapChannelPlugin = {
                 return;
             }
             log?.info?.(`MoltZap: connecting as ${account.agentName} to ${account.serverUrl}`);
-            const senderNameCache = new Map();
-            const conversationMetaCache = new Map();
-            async function lookupSenderName(client, agentId) {
-                const cached = senderNameCache.get(agentId);
-                if (cached)
-                    return cached;
-                try {
-                    const result = (await client.sendRpc("agents/lookup", {
-                        agentIds: [agentId],
-                    }));
-                    const agent = result.agents[0];
-                    if (agent) {
-                        senderNameCache.set(agentId, agent.name);
-                        return agent.name;
-                    }
-                }
-                catch {
-                    log?.warn?.(`MoltZap: agents/lookup failed for ${agentId}`);
+            const wsLogger = log
+                ? {
+                    info: log.info ?? (() => { }),
+                    warn: log.warn ?? (() => { }),
+                    error: log.error ?? (() => { }),
                 }
-                return agentId;
-            }
-            async function getConversationMeta(client, conversationId) {
-                const cached = conversationMetaCache.get(conversationId);
-                if (cached)
-                    return cached;
-                try {
-                    const result = (await client.sendRpc("conversations/get", {
-                        conversationId,
-                    }));
-                    const meta = {
-                        type: result.conversation.type,
-                        name: result.conversation.name,
-                        participants: result.participants.map((p) => `${p.participant.type}:${p.participant.id}`),
-                    };
-                    conversationMetaCache.set(conversationId, meta);
-                    return meta;
-                }
-                catch {
-                    log?.warn?.(`MoltZap: conversations/get failed for ${conversationId}`);
-                    return undefined;
-                }
-            }
-            // Serialize dispatches — OpenClaw's workspace-state writer can't handle
-            // concurrent writes within the same process.
-            let dispatchChain = Promise.resolve();
-            let ownAgentId;
-            function dispatchMessage(message, client) {
-                // Skip messages sent by this agent (avoid echo loops)
-                if (ownAgentId &&
-                    message.sender.type === "agent" &&
-                    message.sender.id === ownAgentId) {
+                : undefined;
+            const service = new MoltZapService({
+                serverUrl: account.serverUrl,
+                agentKey: account.apiKey,
+                logger: wsLogger,
+            });
+            const core = new MoltZapChannelCore({ service, logger: wsLogger });
+            core.onInbound(async (enriched) => {
+                const chatType = enriched.conversationMeta?.type === "group" ? "group" : "direct";
+                const fromId = `${enriched.sender.type}:${enriched.sender.id}`;
+                log?.info?.(`MoltZap: inbound from ${fromId}: ${enriched.text.slice(0, 80)}`);
+                setStatus({
+                    accountId,
+                    lastInboundAt: Date.now(),
+                    lastEventAt: Date.now(),
+                });
+                const crossConvBlock = formatCrossConversationBlock(enriched.contextBlocks.crossConversation ?? [], {
+                    header: `Recent updates (you are in conv:${enriched.conversationId}):`,
+                });
+                const bodyForAgent = crossConvBlock
+                    ? `${crossConvBlock}\n\n${enriched.text}`
+                    : enriched.text;
+                if (!ctx.channelRuntime?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
                     return;
                 }
-                dispatchChain = dispatchChain
-                    .then(async () => {
-                    const [senderName, convMeta] = await Promise.all([
-                        message.sender.type === "agent"
-                            ? lookupSenderName(client, message.sender.id)
-                            : Promise.resolve(undefined),
-                        getConversationMeta(client, message.conversationId),
-                    ]);
-                    const envelope = mapMessageToEnvelope(message, {
-                        senderName,
-                        chatType: convMeta?.type === "group"
-                            ? "group"
-                            : convMeta?.type === "dm"
-                                ? "direct"
-                                : undefined,
-                        groupSubject: convMeta?.name,
-                        groupMembers: convMeta?.participants.join(","),
-                        conversationLabel: convMeta?.name,
-                    });
-                    log?.info?.(`MoltZap: inbound from ${envelope.peer.id}: ${envelope.text.slice(0, 80)}`);
-                    setStatus({
-                        accountId,
-                        lastInboundAt: Date.now(),
-                        lastEventAt: Date.now(),
+                const groupSubject = enriched.conversationMeta?.name;
+                const groupMembers = enriched.conversationMeta?.type === "group"
+                    ? enriched.conversationMeta.participants.join(",")
+                    : undefined;
+                try {
+                    const result = await ctx.channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
+                        ctx: {
+                            Body: enriched.text,
+                            BodyForAgent: bodyForAgent,
+                            From: fromId,
+                            To: account.agentName ?? accountId,
+                            SessionKey: `agent:main:moltzap:${chatType === "group" ? "group" : "dm"}:${enriched.conversationId}`,
+                            AccountId: accountId,
+                            Provider: CHANNEL_ID,
+                            Surface: CHANNEL_ID,
+                            OriginatingChannel: CHANNEL_ID,
+                            OriginatingTo: enriched.conversationId,
+                            ChatType: chatType,
+                            ...(groupSubject ? { GroupSubject: groupSubject } : {}),
+                            ...(groupMembers ? { GroupMembers: groupMembers } : {}),
+                            ...(enriched.conversationMeta?.name
+                                ? { ConversationLabel: enriched.conversationMeta.name }
+                                : {}),
+                            SenderName: enriched.sender.name,
+                        },
+                        cfg: ctx.cfg,
+                        dispatcherOptions: {
+                            deliver: async (payload, info) => {
+                                if (info?.kind !== "final")
+                                    return true;
+                                const text = payload.text ?? payload.body;
+                                if (!text)
+                                    return true;
+                                try {
+                                    await core.sendReply(enriched.conversationId, text);
+                                    log?.info?.(`MoltZap: outbound reply to ${enriched.conversationId}: ${text.slice(0, 80)}`);
+                                    return true;
+                                }
+                                catch (sendErr) {
+                                    log?.error?.(`MoltZap: failed to send reply: ${sendErr}`);
+                                    return false;
+                                }
+                            },
+                        },
                     });
-                    if (ctx.channelRuntime?.reply
-                        ?.dispatchReplyWithBufferedBlockDispatcher) {
-                        try {
-                            const result = await ctx.channelRuntime.reply.dispatchReplyWithBufferedBlockDispatcher({
-                                ctx: {
-                                    Body: envelope.text,
-                                    BodyForAgent: envelope.text,
-                                    From: envelope.peer.id,
-                                    To: account.agentName ?? accountId,
-                                    SessionKey: `agent:main:moltzap:dm:${envelope.conversationId}`,
-                                    AccountId: accountId,
-                                    Provider: CHANNEL_ID,
-                                    Surface: CHANNEL_ID,
-                                    OriginatingChannel: CHANNEL_ID,
-                                    OriginatingTo: envelope.conversationId,
-                                    ...(envelope.chatType
-                                        ? { ChatType: envelope.chatType }
-                                        : {}),
-                                    ...(envelope.groupSubject
-                                        ? { GroupSubject: envelope.groupSubject }
-                                        : {}),
-                                    ...(envelope.groupMembers
-                                        ? { GroupMembers: envelope.groupMembers }
-                                        : {}),
-                                    ...(envelope.conversationLabel
-                                        ? { ConversationLabel: envelope.conversationLabel }
-                                        : {}),
-                                    ...(envelope.senderName
-                                        ? { SenderName: envelope.senderName }
-                                        : {}),
-                                },
-                                cfg: ctx.cfg,
-                                dispatcherOptions: {
-                                    deliver: async (payload, info) => {
-                                        if (info?.kind !== "final")
-                                            return true;
-                                        const text = payload.text ?? payload.body;
-                                        if (!text)
-                                            return true;
-                                        try {
-                                            await client.sendRpc("messages/send", {
-                                                conversationId: envelope.conversationId,
-                                                parts: [{ type: "text", text }],
-                                            });
-                                            log?.info?.(`MoltZap: outbound reply to ${envelope.conversationId}: ${text.slice(0, 80)}`);
-                                            return true;
-                                        }
-                                        catch (sendErr) {
-                                            log?.error?.(`MoltZap: failed to send reply: ${sendErr}`);
-                                            return false;
-                                        }
-                                    },
-                                },
-                            });
-                            if (!result.queuedFinal) {
-                                log?.debug?.(`MoltZap: dispatch completed without final reply for ${envelope.conversationId}`);
-                            }
-                        }
-                        catch (err) {
-                            log?.error?.(`MoltZap: dispatch error: ${err}`);
-                        }
-                    }
-                })
-                    .catch((err) => {
-                    log?.error?.(`MoltZap: dispatch chain error: ${err}`);
-                });
-            }
-            async function fetchMissedMessages(client, helloOk) {
-                const hello = helloOk;
-                const unreadCounts = hello?.unreadCounts;
-                if (!unreadCounts)
-                    return;
-                const sorted = Object.entries(unreadCounts)
-                    .filter(([, count]) => count > 0)
-                    .sort(([, a], [, b]) => b - a)
-                    .slice(0, 5);
-                let totalFetched = 0;
-                for (const [conversationId] of sorted) {
-                    try {
-                        const result = (await client.sendRpc("messages/list", {
-                            conversationId,
-                            limit: 50,
-                        }));
-                        for (const msg of result.messages) {
-                            dispatchMessage(msg, client);
-                        }
-                        totalFetched += result.messages.length;
-                    }
-                    catch {
-                        log?.warn?.(`MoltZap: failed to fetch missed messages for ${conversationId}`);
+                    if (!result.queuedFinal) {
+                        log?.debug?.(`MoltZap: dispatch completed without final reply for ${enriched.conversationId}`);
                     }
                 }
-                if (totalFetched > 0) {
-                    log?.info?.(`MoltZap: fetched ${totalFetched} missed messages from ${sorted.length} conversations`);
+                catch (err) {
+                    log?.error?.(`MoltZap: dispatch error: ${err}`);
                 }
-            }
-            const eventHandlers = {
-                "messages/received": (event) => {
-                    const message = extractMessage(event);
-                    if (message)
-                        dispatchMessage(message, client);
-                },
-                "messages/read": (event) => {
-                    const receipt = extractReadReceipt(event);
-                    if (receipt) {
-                        log?.debug?.(`MoltZap: read receipt from ${receipt.participant.id} in ${receipt.conversationId} up to seq ${receipt.seq}`);
-                        setStatus({ accountId, lastEventAt: Date.now() });
-                    }
-                },
-                "messages/delivered": (event) => {
-                    const delivery = extractDelivery(event);
-                    if (delivery) {
-                        log?.debug?.(`MoltZap: delivery for ${delivery.messageId} in ${delivery.conversationId}`);
-                        setStatus({ accountId, lastEventAt: Date.now() });
-                    }
-                },
-                "messages/reacted": (event) => {
-                    const reaction = extractReaction(event);
-                    if (reaction) {
-                        log?.debug?.(`MoltZap: reaction ${reaction.action} ${reaction.emoji} on ${reaction.messageId}`);
-                        setStatus({ accountId, lastEventAt: Date.now() });
-                    }
-                },
-                "messages/deleted": (event) => {
-                    const deletion = extractDeletion(event);
-                    if (deletion) {
-                        log?.debug?.(`MoltZap: message ${deletion.messageId} deleted in ${deletion.conversationId}`);
-                        setStatus({ accountId, lastEventAt: Date.now() });
+            });
+            // Forward non-message events for status/logging
+            service.on("rawEvent", (event) => {
+                switch (event.event) {
+                    case EventNames.MessageRead: {
+                        const receipt = extractReadReceipt(event);
+                        if (receipt) {
+                            log?.debug?.(`MoltZap: read receipt from ${receipt.participant.id} in ${receipt.conversationId} up to seq ${receipt.seq}`);
+                            setStatus({ accountId, lastEventAt: Date.now() });
+                        }
+                        break;
                     }
-                },
-                "conversations/created": (event) => {
-                    const created = extractConversationCreated(event);
-                    if (created) {
-                        conversationMetaCache.set(created.conversation.id, {
-                            type: created.conversation.type,
-                            name: created.conversation.name,
-                            participants: [],
-                        });
-                        log?.debug?.(`MoltZap: conversation created ${created.conversation.id}`);
-                        setStatus({ accountId, lastEventAt: Date.now() });
+                    case EventNames.MessageDelivered: {
+                        const delivery = extractDelivery(event);
+                        if (delivery) {
+                            log?.debug?.(`MoltZap: delivery for ${delivery.messageId} in ${delivery.conversationId}`);
+                            setStatus({ accountId, lastEventAt: Date.now() });
+                        }
+                        break;
                     }
-                },
-                "conversations/updated": (event) => {
-                    const updated = extractConversationUpdated(event);
-                    if (updated) {
-                        const existing = conversationMetaCache.get(updated.conversation.id);
-                        conversationMetaCache.set(updated.conversation.id, {
-                            type: updated.conversation.type,
-                            name: updated.conversation.name,
-                            participants: existing?.participants ?? [],
-                        });
-                        log?.debug?.(`MoltZap: conversation updated ${updated.conversation.id}`);
-                        setStatus({ accountId, lastEventAt: Date.now() });
+                    case EventNames.MessageReacted: {
+                        const reaction = extractReaction(event);
+                        if (reaction) {
+                            log?.debug?.(`MoltZap: reaction ${reaction.action} ${reaction.emoji} on ${reaction.messageId}`);
+                            setStatus({ accountId, lastEventAt: Date.now() });
+                        }
+                        break;
                     }
-                },
-                "contact/request": (event) => {
-                    const contact = extractContactRequest(event);
-                    if (contact) {
-                        log?.debug?.(`MoltZap: contact request from ${contact.contact.requesterId}`);
-                        setStatus({ accountId, lastEventAt: Date.now() });
+                    case EventNames.MessageDeleted: {
+                        const deletion = extractDeletion(event);
+                        if (deletion) {
+                            log?.debug?.(`MoltZap: message ${deletion.messageId} deleted in ${deletion.conversationId}`);
+                            setStatus({ accountId, lastEventAt: Date.now() });
+                        }
+                        break;
                     }
-                },
-                "contact/accepted": (event) => {
-                    const contact = extractContactAccepted(event);
-                    if (contact) {
-                        log?.debug?.(`MoltZap: contact accepted ${contact.contact.id}`);
-                        setStatus({ accountId, lastEventAt: Date.now() });
+                    case EventNames.ConversationCreated: {
+                        const created = extractConversationCreated(event);
+                        if (created) {
+                            log?.debug?.(`MoltZap: conversation created ${created.conversation.id}`);
+                            setStatus({ accountId, lastEventAt: Date.now() });
+                        }
+                        break;
                     }
-                },
-                "presence/changed": (event) => {
-                    const presence = extractPresenceChanged(event);
-                    if (presence) {
-                        log?.debug?.(`MoltZap: ${presence.participant.id} is now ${presence.status}`);
-                        setStatus({ accountId, lastEventAt: Date.now() });
+                    case EventNames.ConversationUpdated: {
+                        const updated = extractConversationUpdated(event);
+                        if (updated) {
+                            log?.debug?.(`MoltZap: conversation updated ${updated.conversation.id}`);
+                            setStatus({ accountId, lastEventAt: Date.now() });
+                        }
+                        break;
                     }
-                },
-                "typing/indicator": (event) => {
-                    const typing = extractTypingIndicator(event);
-                    if (typing) {
-                        log?.debug?.(`MoltZap: typing in ${typing.conversationId} by ${typing.participant.id}`);
+                    case EventNames.ContactRequest: {
+                        const contact = extractContactRequest(event);
+                        if (contact) {
+                            log?.debug?.(`MoltZap: contact request from ${contact.contact.requesterId}`);
+                            setStatus({ accountId, lastEventAt: Date.now() });
+                        }
+                        break;
                     }
-                },
-            };
-            const client = new MoltZapWsClient({
-                serverUrl: account.serverUrl,
-                agentKey: account.apiKey,
-                logger: log
-                    ? {
-                        info: log.info ?? (() => { }),
-                        warn: log.warn ?? (() => { }),
-                        error: log.error ?? (() => { }),
+                    case EventNames.ContactAccepted: {
+                        const contact = extractContactAccepted(event);
+                        if (contact) {
+                            log?.debug?.(`MoltZap: contact accepted ${contact.contact.id}`);
+                            setStatus({ accountId, lastEventAt: Date.now() });
+                        }
+                        break;
                     }
-                    : undefined,
-                onEvent: (event) => {
-                    const handler = eventHandlers[event.event];
-                    if (handler) {
-                        handler(event);
+                    case EventNames.PresenceChanged: {
+                        const presence = extractPresenceChanged(event);
+                        if (presence) {
+                            log?.debug?.(`MoltZap: ${presence.participant.id} is now ${presence.status}`);
+                            setStatus({ accountId, lastEventAt: Date.now() });
+                        }
+                        break;
                     }
-                    else {
-                        log?.debug?.(`MoltZap: unhandled event type: ${event.event}`);
+                    case EventNames.TypingIndicator: {
+                        const typing = extractTypingIndicator(event);
+                        if (typing) {
+                            log?.debug?.(`MoltZap: typing in ${typing.conversationId} by ${typing.participant.id}`);
+                        }
+                        break;
                     }
-                },
-                onDisconnect: () => {
-                    log?.warn?.("MoltZap: disconnected");
-                    setStatus({
-                        accountId,
-                        connected: false,
-                        lastDisconnect: { at: Date.now() },
-                    });
-                },
-                onReconnect: (helloOk) => {
-                    log?.info?.("MoltZap: reconnected");
-                    setStatus({
-                        accountId,
-                        connected: true,
-                        lastConnectedAt: Date.now(),
-                    });
-                    populateConversationCache(helloOk);
-                    void fetchMissedMessages(client, helloOk);
-                },
-            });
-            function populateConversationCache(helloOk) {
-                const hello = helloOk;
-                if (!hello?.conversations)
-                    return;
-                for (const conv of hello.conversations) {
-                    conversationMetaCache.set(conv.id, {
-                        type: conv.type,
-                        name: conv.name,
-                        participants: (conv.participants ?? []).map((p) => `${p.type}:${p.id}`),
-                    });
                 }
+            });
+            core.onDisconnect(() => {
+                log?.warn?.("MoltZap: disconnected");
+                setStatus({
+                    accountId,
+                    connected: false,
+                    lastDisconnect: { at: Date.now() },
+                });
+            });
+            core.onReconnect(() => {
+                log?.info?.("MoltZap: reconnected");
+                setStatus({
+                    accountId,
+                    connected: true,
+                    lastConnectedAt: Date.now(),
+                });
+            });
+            activeClients.set(accountId, service);
+            if (abortSignal.aborted) {
+                await core.disconnect();
+                activeClients.delete(accountId);
+                return;
             }
-            activeClients.set(accountId, client);
             abortSignal.addEventListener("abort", () => {
-                client.close();
+                void core.disconnect();
                 activeClients.delete(accountId);
             }, { once: true });
             try {
-                const helloOk = await client.connect();
-                ownAgentId = helloOk?.agentId;
-                log?.info?.(`MoltZap: connected as ${account.agentName} (${ownAgentId})`);
+                await core.connect();
+                service.startSocketServer();
+                log?.info?.(`MoltZap: connected as ${account.agentName} (${service.ownAgentId})`);
                 setStatus({
                     accountId,
                     connected: true,
                     lastConnectedAt: Date.now(),
                 });
-                populateConversationCache(helloOk);
                 // Keep the gateway task alive until abort.
                 await new Promise((resolve) => {
                     abortSignal.addEventListener("abort", () => resolve(), {
@@ -482,12 +358,11 @@ export const moltzapChannelPlugin = {
             }
         },
         async stopAccount(ctx) {
-            const client = activeClients.get(ctx.accountId);
-            if (client) {
+            const service = activeClients.get(ctx.accountId);
+            if (service) {
                 ctx.log?.info?.("MoltZap: stopping");
-                client.close();
+                service.close();
                 activeClients.delete(ctx.accountId);
-                agentConversationCache.delete(ctx.accountId);
             }
         },
     },
@@ -508,43 +383,28 @@ export const moltzapChannelPlugin = {
         },
         async sendText(ctx) {
             const accountId = ctx.accountId ?? DEFAULT_ACCOUNT_ID;
-            const client = activeClients.get(accountId);
-            if (!client) {
+            const service = activeClients.get(accountId);
+            if (!service) {
                 return {
                     ok: false,
                     error: new Error("MoltZap client not connected"),
                 };
             }
             try {
-                let conversationId;
                 if (ctx.to.startsWith(TARGET_PREFIX_AGENT)) {
                     const agentName = ctx.to.slice(TARGET_PREFIX_AGENT.length);
-                    const accountCache = agentConversationCache.get(accountId) ?? new Map();
-                    conversationId = accountCache.get(agentName);
-                    if (!conversationId) {
-                        const lookupResult = (await client.sendRpc("agents/lookupByName", {
-                            name: agentName,
-                        }));
-                        const createResult = (await client.sendRpc("conversations/create", {
-                            type: "dm",
-                            participants: [{ type: "agent", id: lookupResult.agent.id }],
-                        }));
-                        conversationId = createResult.conversation.id;
-                        accountCache.set(agentName, conversationId);
-                        agentConversationCache.set(accountId, accountCache);
-                    }
-                }
-                else if (ctx.to.startsWith(TARGET_PREFIX_CONV)) {
-                    conversationId = ctx.to.slice(TARGET_PREFIX_CONV.length);
+                    await service.sendToAgent(agentName, ctx.text, {
+                        replyTo: ctx.replyToId,
+                    });
                 }
                 else {
-                    conversationId = ctx.to;
+                    const conversationId = ctx.to.startsWith(TARGET_PREFIX_CONV)
+                        ? ctx.to.slice(TARGET_PREFIX_CONV.length)
+                        : ctx.to;
+                    await service.send(conversationId, ctx.text, {
+                        replyTo: ctx.replyToId,
+                    });
                 }
-                await client.sendRpc("messages/send", {
-                    conversationId,
-                    parts: [{ type: "text", text: ctx.text }],
-                    ...(ctx.replyToId ? { replyToId: ctx.replyToId } : {}),
-                });
                 return { ok: true };
             }
             catch (err) {