palz-connector 1.7.0 → 1.7.2

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "palz-connector",
   "name": "Palz Connector Channel",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "description": "Palz IM 接入 OpenClaw",
   "channels": [
     "palz-connector"

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "palz-connector",
-  "version": "1.7.0",
+  "version": "1.7.2",
   "type": "module",
   "main": "index.js",
   "description": "Palz IM 接入 OpenClaw — 模块化架构，基于 OpenClaw Runtime 消息管道",
   "scripts": {
-    "build": "tsc"
+    "build": "tsc",
+    "prepack": "npm run build"
   },
   "files": [
     "index.js",

package/palz-connector.global.dev.config.json

@@ -0,0 +1,12 @@
+{
+  "enabled": true,
+  "streamUrl": "ws://claw-server:8787/ws/bot",
+  "apiBaseUrl": "http://claw-server:8787/api",
+  "clawGatewayUrl": "http://claw-gateway:8080",
+  "activityReportEnabled": true,
+  "sessionTimeout": 1800000,
+  "groupContextCache": false,
+  "showProcess": true,
+  "kbEngineUrl": "http://uniclaw-kb-engine:8070",
+  "controlPort": 8008
+}

package/palz-connector.global.prod.config.json

@@ -0,0 +1,12 @@
+{
+  "enabled": true,
+  "streamUrl": "ws://claw-server:8787/ws/bot",
+  "apiBaseUrl": "http://claw-server:8787/api",
+  "clawGatewayUrl": "http://claw-gateway:8080",
+  "activityReportEnabled": true,
+  "sessionTimeout": 1800000,
+  "groupContextCache": false,
+  "showProcess": true,
+  "kbEngineUrl": "http://uniclaw-kb-engine:8070",
+  "controlPort": 8008
+}

package/palz-connector.global.staging.config.json

@@ -0,0 +1,12 @@
+{
+  "enabled": true,
+  "streamUrl": "ws://claw-server:8787/ws/bot",
+  "apiBaseUrl": "http://claw-server:8787/api",
+  "clawGatewayUrl": "http://claw-gateway:8080",
+  "activityReportEnabled": true,
+  "sessionTimeout": 1800000,
+  "groupContextCache": false,
+  "showProcess": true,
+  "kbEngineUrl": "http://uniclaw-kb-engine:8070",
+  "controlPort": 8008
+}

package/src/activity.js

@@ -1,9 +1,10 @@
 /**
- * Palz IM 收到消息后的 claw-gateway 活动上报。
+ * Palz IM WebSocket 连接成功后的 claw-gateway 活动上报。
  */
 const ACTIVITY_REPORT_TIMEOUT_MS = 2000;
 const ACTIVITY_REPORT_PATH_PREFIX = "/openclaw-gateway/be/deployments";
 const warnedMissingConfig = new Set();
+const SERVICE_NAME = process.env.OPENCLAW_WORKSPACE_POOL_SERVICE_NAME ?? "";
 function formatDateTimeWithOffset(date) {
     const pad = (n, width = 2) => String(n).padStart(width, "0");
     const offsetMinutes = -date.getTimezoneOffset();
@@ -23,7 +24,7 @@ function resolveActivityUrl(baseUrl, releaseName) {
     return `${normalizedBase}${ACTIVITY_REPORT_PATH_PREFIX}/${encodeURIComponent(releaseName)}/activity`;
 }
 export async function reportPalzActivity(params) {
-    const { config, msg, receivedAt, runtime, accountId } = params;
+    const { config, connectedAt, runtime, accountId } = params;
     const log = typeof runtime?.log === "function" ? runtime.log : console.log;
     const error = typeof runtime?.error === "function" ? runtime.error : console.error;
     const tag = `palz[${accountId ?? config.botId ?? "default"}]`;
@@ -41,22 +42,17 @@ export async function reportPalzActivity(params) {
     }
     const payload = {
         source: "palz-connector",
-        eventType: "im_message_received",
-        messageId: msg.msg_id,
-        conversationId: msg.conversation_id,
-        conversationType: msg.conversation_type || "direct",
-        userId: msg.owner_id ?? "",
-        senderId: msg.sender_id,
-        receivedAt: formatDateTimeWithOffset(receivedAt),
+        eventType: "ws_connected",
+        releaseName,
+        serviceName: SERVICE_NAME,
+        connectedAt: formatDateTimeWithOffset(connectedAt),
     };
-    if (msg.traceparent) {
-        payload.traceId = msg.traceparent;
-    }
     const url = resolveActivityUrl(baseUrl, releaseName);
     const body = JSON.stringify(payload);
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), ACTIVITY_REPORT_TIMEOUT_MS);
     const startMs = Date.now();
+    log(`${tag}: [ACTIVITY_REPORT] reporting eventType=ws_connected url=${url} body=${body}`);
     try {
         const response = await fetch(url, {
             method: "POST",
@@ -67,15 +63,15 @@ export async function reportPalzActivity(params) {
         const elapsedMs = Date.now() - startMs;
         const responseText = await response.text().catch(() => "");
         if (!response.ok) {
-            error(`${tag}: [ACTIVITY_REPORT] failed status=${response.status} elapsed=${elapsedMs}ms msg_id=${msg.msg_id} response=${responseText.slice(0, 300)}`);
+            error(`${tag}: [ACTIVITY_REPORT] failed status=${response.status} elapsed=${elapsedMs}ms response=${responseText.slice(0, 300)}`);
             return;
         }
-        log(`${tag}: [ACTIVITY_REPORT] ok status=${response.status} elapsed=${elapsedMs}ms msg_id=${msg.msg_id}`);
+        log(`${tag}: [ACTIVITY_REPORT] ok status=${response.status} elapsed=${elapsedMs}ms eventType=ws_connected`);
     }
     catch (err) {
         const elapsedMs = Date.now() - startMs;
         const reason = err?.name === "AbortError" ? `timeout ${ACTIVITY_REPORT_TIMEOUT_MS}ms` : (err?.message ?? String(err));
-        error(`${tag}: [ACTIVITY_REPORT] error elapsed=${elapsedMs}ms msg_id=${msg.msg_id} reason=${reason}`);
+        error(`${tag}: [ACTIVITY_REPORT] error elapsed=${elapsedMs}ms reason=${reason}`);
     }
     finally {
         clearTimeout(timeout);

package/src/bot.js

@@ -19,6 +19,7 @@ import { extractFileUrls, ingestFilesToKbEngine } from "./kb-ingest.js";
 import { consumeKbTaskContext, extractKbTaskCallbackContent, extractKbTaskId, resolveKbTaskContext, } from "./kb-task-callback.js";
 import { sendToPalzIM } from "./send.js";
 import { buildPassthroughFromMsg } from "./message-utils.js";
+import { buildPalzGatewayRelayContext, runWithPalzGatewayRelay } from "./gateway-relay.js";
 import { tracer, trace, context, SpanStatusCode } from "./tracing.js";
 // ============ 文本提取工具 ============
 function extractPlainText(content) {
@@ -209,6 +210,24 @@ function buildMediaPayload(mediaList) {
         MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
     };
 }
+function buildUniclawEventContext(params) {
+    return {
+        label: "Uniclaw event",
+        source: "palz-connector",
+        type: "server.message_event.v1",
+        payload: {
+            raw: params.msg,
+            route: {
+                agent_id: params.effectiveAgentId,
+                session_key: params.route?.sessionKey,
+                account_id: params.route?.accountId || params.accountId,
+                chat_type: params.chatType,
+                group_id: params.groupId || "",
+                was_mentioned: params.wasMentioned,
+            },
+        },
+    };
+}
 function buildFileSharingSystemPrompt() {
     return [
         "## File Sharing",
@@ -678,6 +697,15 @@ async function _dispatchPalzMessageInner(params) {
         SenderId: msg.sender_id,
         SenderName: senderName,
         UntrustedContext: untrustedContext,
+        UntrustedStructuredContext: [buildUniclawEventContext({
+                msg,
+                effectiveAgentId,
+                route,
+                accountId,
+                chatType,
+                groupId,
+                wasMentioned,
+            })],
         Provider: "palz-connector",
         Surface: "palz-connector",
         MessageSid: msg.msg_id,
@@ -810,6 +838,13 @@ async function _dispatchPalzMessageInner(params) {
     log(`${tag}: ${step6dStart}`);
     span?.addEvent(step6dStart);
     const dispatchStartMs = Date.now();
+    const palzRelay = buildPalzGatewayRelayContext({
+        msg,
+        accountId,
+        agentId: effectiveAgentId,
+        relayInput: { config, route, ctx, plainText, useStream, groupId },
+        runtime,
+    });
     let queuedFinal = false;
     let counts = {};
     let attempt = 0; // 已重生成次数
@@ -818,7 +853,7 @@ async function _dispatchPalzMessageInner(params) {
     let blockedByRiskControl = false; // 最近一轮是否仍被风控拦截
     while (true) {
         const { dispatcher, replyOptions, markDispatchIdle, riskControl } = makeDispatcher();
-        const result = await core.channel.reply.withReplyDispatcher({
+        const result = await runWithPalzGatewayRelay(palzRelay, () => core.channel.reply.withReplyDispatcher({
             dispatcher,
             onSettled: () => markDispatchIdle(),
             run: () => core.channel.reply.dispatchReplyFromConfig({
@@ -827,7 +862,7 @@ async function _dispatchPalzMessageInner(params) {
                 dispatcher,
                 replyOptions,
             }),
-        });
+        }));
         queuedFinal = result.queuedFinal;
         counts = result.counts;
         // withReplyDispatcher 返回时 sendChain（含 HTTP send）已 settle，风控结果已确定。

package/src/gateway-relay.js

@@ -0,0 +1,340 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const PALZ_RELAY_HOP_HEADER = "X-Uniclaw-Palz-Relay-Hop";
+const PALZ_RELAY_SOURCE_PHYSICAL_HEADER = "X-Uniclaw-Palz-Relay-Source-Physical";
+const PALZ_RELAY_HOP_OPENCLAW_AGENT = "openclaw-agent";
+const PALZ_GATEWAY_RELAY_GLOBAL_KEY = "__uniclawPalzGatewayRelay";
+const PALZ_GATEWAY_RELAY_NATIVE_VERSION = "1.8.0";
+const gatewayRelayNotConfiguredError = "OPENCLAW_PALZ_RELAY_URL is required for palz gateway relay";
+const relayStorage = new AsyncLocalStorage();
+let fetchPatched = false;
+function exposePalzGatewayRelayGlobal() {
+    const existing = globalThis[PALZ_GATEWAY_RELAY_GLOBAL_KEY] ?? {};
+    if (existing.__palzConnectorNativeVersion === PALZ_GATEWAY_RELAY_NATIVE_VERSION)
+        return;
+    globalThis[PALZ_GATEWAY_RELAY_GLOBAL_KEY] = {
+        ...existing,
+        __palzConnectorNativeVersion: PALZ_GATEWAY_RELAY_NATIVE_VERSION,
+        currentPalzGatewayRelay: () => currentPalzGatewayRelay(),
+        runWithPalzGatewayRelay: (context, fn) => {
+            if (!context || !normalize(context.relayUrl))
+                throw new Error(gatewayRelayNotConfiguredError);
+            return relayStorage.run(context, fn);
+        },
+    };
+}
+function normalize(value) {
+    return String(value ?? "").trim();
+}
+function randomRelayKey() {
+    try {
+        const bytes = new Uint8Array(16);
+        crypto.getRandomValues(bytes);
+        return Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    }
+    catch {
+        return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
+    }
+}
+function palzMessageContent(msg, relayInput) {
+    const direct = normalize(relayInput.plainText || msg.plainText || msg.text || msg.body || msg.Body);
+    if (direct)
+        return direct;
+    const content = msg.content;
+    if (typeof content === "string")
+        return normalize(content);
+    if (Array.isArray(content)) {
+        return content
+            .map((item) => typeof item === "string" ? item : normalize(item?.text || item?.content))
+            .filter(Boolean)
+            .join("\n");
+    }
+    return "";
+}
+export function buildPalzGatewayRelayContext(params) {
+    const relayUrl = normalize(process.env.OPENCLAW_PALZ_RELAY_URL);
+    if (!relayUrl) {
+        const runtime = params.runtime;
+        const logError = typeof runtime?.error === "function" ? runtime.error : console.error;
+        logError(`[GATEWAY_RELAY] ${gatewayRelayNotConfiguredError}`);
+        throw new Error(gatewayRelayNotConfiguredError);
+    }
+    const { msg, accountId, agentId, relayInput, runtime } = params;
+    const ctx = relayInput.ctx ?? {};
+    const releaseName = normalize(accountId || msg.release_name || msg.releaseName);
+    const userId = releaseName.replace(/^user-/, "");
+    const agent = normalize(agentId || msg.agent_id);
+    return {
+        relayUrl,
+        apiKey: normalize(process.env.CLAW_GATEWAY_API_KEY || process.env.OPENCLAW_GATEWAY_API_KEY),
+        namespace: normalize(process.env.OPENCLAW_POD_NAMESPACE || process.env.POD_NAMESPACE),
+        releaseName,
+        logicalReleaseName: releaseName,
+        physicalReleaseName: normalize(process.env.OPENCLAW_WORKSPACE_POOL_PHYSICAL_RELEASE || process.env.botID),
+        userId,
+        agentId: agent,
+        runtimeAgentId: agent,
+        prewarmKey: randomRelayKey(),
+        conversationId: normalize(msg.conversation_id || msg.conversationId || relayInput.groupId || ctx.conversation_id || ctx.conversationId),
+        conversationType: normalize(msg.conversation_type || msg.conversationType || (relayInput.groupId ? "group" : "")),
+        senderId: normalize(msg.sender_id || msg.senderId || msg.from || ctx.sender_id || ctx.senderId),
+        senderName: normalize(msg.sender_name || msg.senderName || msg.nick || msg.nickname || ctx.sender_name || ctx.senderName),
+        senderAccountType: normalize(msg.sender_account_type || msg.senderAccountType || ctx.sender_account_type || ctx.senderAccountType),
+        ownerId: normalize(msg.owner_id || msg.ownerId || ctx.owner_id || ctx.ownerId),
+        ownerName: normalize(msg.owner_name || msg.ownerName || ctx.owner_name || ctx.ownerName),
+        groupId: normalize(relayInput.groupId || msg.group_id || msg.groupId),
+        groupKind: ctx.group_kind ?? ctx.groupKind ?? msg.group_kind ?? msg.groupKind,
+        msgId: normalize(msg.msg_id || msg.msgId || msg.message_id || msg.messageId),
+        mentionedBot: msg.mentioned_bot ?? msg.mentionedBot ?? ctx.mentioned_bot ?? ctx.mentionedBot,
+        lobsterId: normalize(msg.lobster_id || msg.lobsterId || msg.agent_id || msg.agentId || agent),
+        lobsterName: normalize(msg.lobster_name || msg.lobsterName || msg.agent_name || msg.agentName),
+        lobsterType: normalize(msg.lobster_type || msg.lobsterType),
+        groupMembersList: ctx.group_members_list || ctx.groupMembersList || msg.group_members_list || msg.groupMembersList || null,
+        groupLobsters: ctx.group_lobsters || ctx.groupLobsters || msg.group_lobsters || msg.groupLobsters || null,
+        content: palzMessageContent(msg, relayInput),
+        message: msg,
+        context: ctx || null,
+        route: relayInput.route || null,
+        relayInput,
+        log: typeof runtime?.log === "function" ? runtime.log : console.log,
+        error: typeof runtime?.error === "function" ? runtime.error : console.error,
+    };
+}
+export function currentPalzGatewayRelay() {
+    return relayStorage.getStore() ?? null;
+}
+export async function runWithPalzGatewayRelay(relay, fn) {
+    if (!relay)
+        throw new Error("palz gateway relay context is required");
+    exposePalzGatewayRelayGlobal();
+    installPalzGatewayRelayFetchPatch();
+    relay.log?.(`[GATEWAY_RELAY] armed transparent transport relay url=${relay.relayUrl} release=${relay.releaseName ?? ""} agent=${relay.agentId ?? ""} msg_id=${relay.msgId ?? ""}`);
+    return relayStorage.run(relay, fn);
+}
+function requestURL(url) {
+    if (url && typeof url === "object" && "url" in url) {
+        return normalize(url.url);
+    }
+    return normalize(url);
+}
+function shouldInterceptModelRequest(url) {
+    const raw = requestURL(url);
+    return /\/v1\/api\/.+\/(chat\/completions|images\/generations|video\/generations)|\/v1\/api\/(chat\/completions|images\/generations|video\/generations)/.test(raw);
+}
+function withLocatorHeaders(init, relay) {
+    if (!normalize(relay.userId))
+        return init;
+    const next = { ...(init ?? {}) };
+    const headers = new Headers(next.headers);
+    headers.set("X-CLAW-USER", `uniclaw-user-locator:${normalize(relay.userId)}`);
+    headers.set("X-OpenClaw-User-ID", normalize(relay.userId));
+    if (normalize(relay.agentId)) {
+        headers.set("X-OpenClaw-Agent-ID", normalize(relay.agentId));
+        headers.set("X-Uniclaw-Agent-Id", normalize(relay.agentId));
+    }
+    if (normalize(relay.releaseName))
+        headers.set("X-Uniclaw-Owner-Ref", normalize(relay.releaseName));
+    if (normalize(relay.physicalReleaseName))
+        headers.set("X-OpenClaw-Physical-Release", normalize(relay.physicalReleaseName));
+    if (normalize(relay.prewarmKey))
+        headers.set("X-Uniclaw-Palz-Prewarm-Key", normalize(relay.prewarmKey));
+    next.headers = headers;
+    return next;
+}
+function parseRequestBodyText(text) {
+    const trimmed = text.trim();
+    if (!trimmed)
+        return null;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return null;
+    }
+}
+function parseGatewayRelayResponseText(raw) {
+    try {
+        return raw ? JSON.parse(raw) : null;
+    }
+    catch {
+        return null;
+    }
+}
+async function requestBodyFromInit(init) {
+    const body = init?.body;
+    if (body == null)
+        return null;
+    let text = "";
+    if (typeof body === "string")
+        text = body;
+    else if (body instanceof Uint8Array)
+        text = new TextDecoder().decode(body);
+    else if (body instanceof ArrayBuffer)
+        text = new TextDecoder().decode(new Uint8Array(body));
+    else if (ArrayBuffer.isView(body))
+        text = new TextDecoder().decode(new Uint8Array(body.buffer, body.byteOffset, body.byteLength));
+    else if (typeof Blob !== "undefined" && body instanceof Blob)
+        text = await body.text().catch(() => "");
+    else if (body && typeof body.getReader === "function")
+        text = await new Response(body).text().catch(() => "");
+    else if (body && typeof body.text === "function")
+        text = await body.text().catch(() => "");
+    return parseRequestBodyText(text);
+}
+async function requestBodyFromFetchInput(input, init) {
+    if (typeof Request !== "undefined" && input instanceof Request) {
+        try {
+            const parsed = parseRequestBodyText(await input.clone().text());
+            if (parsed)
+                return parsed;
+        }
+        catch { }
+    }
+    return requestBodyFromInit(init);
+}
+function headersFromFetchInput(input, init) {
+    const out = {};
+    try {
+        const headers = new Headers(typeof Request !== "undefined" && input instanceof Request ? input.headers : undefined);
+        const initHeaders = new Headers(init?.headers);
+        initHeaders.forEach((value, key) => headers.set(key, value));
+        headers.forEach((value, key) => {
+            out[key] = value;
+        });
+    }
+    catch { }
+    return out;
+}
+function isGatewayOpenClawAgentRelayHop(headers) {
+    const h = new Headers(headers);
+    return normalize(h.get(PALZ_RELAY_HOP_HEADER)) === PALZ_RELAY_HOP_OPENCLAW_AGENT &&
+        Boolean(normalize(h.get(PALZ_RELAY_SOURCE_PHYSICAL_HEADER)));
+}
+function openClawPathFromURL(url) {
+    let pathname = "";
+    try {
+        pathname = new URL(requestURL(url), "http://local").pathname;
+    }
+    catch {
+        pathname = "";
+    }
+    if (!pathname)
+        return "";
+    if (pathname.startsWith("/v1/api/v1/"))
+        return `/v1/${pathname.slice("/v1/api/v1/".length)}`;
+    if (pathname.startsWith("/v1/api/"))
+        return `/v1/${pathname.slice("/v1/api/".length)}`;
+    return pathname;
+}
+function modelResponseFromGatewayData(data) {
+    if (!data)
+        throw new Error("gateway relay response is empty");
+    let body = "";
+    if (typeof data.openclawResponseText === "string" && data.openclawResponseText) {
+        body = data.openclawResponseText;
+    }
+    else if (data.openclawResponse !== undefined && data.openclawResponse !== null) {
+        body = typeof data.openclawResponse === "string" ? data.openclawResponse : JSON.stringify(data.openclawResponse);
+    }
+    else {
+        throw new Error("gateway relay response missing openclawResponse");
+    }
+    const status = Number(data.statusCode || 200) || 200;
+    const contentType = normalize(data.openclawContentType) || "application/json";
+    return new Response(body, { status, headers: { "Content-Type": contentType } });
+}
+async function relayOpenClawRequest(input, url, init, relay) {
+    const requestBody = await requestBodyFromFetchInput(input, init);
+    if (!normalize(relay.relayUrl))
+        throw new Error(gatewayRelayNotConfiguredError);
+    if (!requestBody)
+        throw new Error("failed to capture OpenClaw request body for palz gateway relay");
+    const inboundHeaders = headersFromFetchInput(input, init);
+    if (isGatewayOpenClawAgentRelayHop(inboundHeaders)) {
+        throw new Error("palz gateway relay captured gateway-originated OpenClaw agent hop");
+    }
+    const headers = { "Content-Type": "application/json" };
+    if (normalize(relay.apiKey))
+        headers["X-API-Key"] = normalize(relay.apiKey);
+    const payload = {
+        namespace: relay.namespace,
+        releaseName: relay.releaseName,
+        logicalReleaseName: relay.logicalReleaseName || relay.releaseName,
+        physicalReleaseName: relay.physicalReleaseName,
+        userId: relay.userId,
+        agentId: relay.agentId,
+        runtimeAgentId: relay.runtimeAgentId,
+        prewarmKey: relay.prewarmKey,
+        conversationId: relay.conversationId,
+        conversationType: relay.conversationType,
+        senderId: relay.senderId,
+        senderName: relay.senderName,
+        senderAccountType: relay.senderAccountType,
+        ownerId: relay.ownerId,
+        ownerName: relay.ownerName,
+        groupId: relay.groupId,
+        groupKind: relay.groupKind,
+        msgId: relay.msgId,
+        mentionedBot: relay.mentionedBot,
+        lobsterId: relay.lobsterId,
+        lobsterName: relay.lobsterName,
+        lobsterType: relay.lobsterType,
+        groupMembersList: relay.groupMembersList,
+        groupLobsters: relay.groupLobsters,
+        content: relay.content,
+        message: relay.message,
+        context: relay.context,
+        route: relay.route,
+        relayInput: relay.relayInput,
+        openclawPath: openClawPathFromURL(url),
+        headers: inboundHeaders,
+        openclawRequest: requestBody,
+    };
+    try {
+        relay.log?.(`[GATEWAY_RELAY] forwarding generated OpenClaw request release=${relay.releaseName ?? ""} agent=${relay.agentId ?? ""}`);
+        const resp = await fetch(relay.relayUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(payload),
+        });
+        const raw = await resp.text();
+        const parsed = parseGatewayRelayResponseText(raw);
+        const data = parsed?.data ? parsed.data : parsed;
+        if (data?.skippedInternalRelay) {
+            throw new Error("gateway relay skipped internal shared OpenClaw loop");
+        }
+        if (!resp.ok || !data || data.ok === false) {
+            throw new Error(`gateway relay failed status=${resp.status} body=${raw.slice(0, 500)}`);
+        }
+        const modelResponse = modelResponseFromGatewayData(data);
+        relay.log?.(`[GATEWAY_RELAY] gateway relay returned OpenClaw response status=${modelResponse.status}`);
+        return modelResponse;
+    }
+    catch (err) {
+        relay.error?.(`[GATEWAY_RELAY] gateway relay error=${String(err?.message || err)}`);
+        throw err;
+    }
+}
+export function installPalzGatewayRelayFetchPatch() {
+    if (fetchPatched || typeof globalThis.fetch !== "function")
+        return;
+    const originalFetch = globalThis.fetch.bind(globalThis);
+    globalThis.fetch = async (input, init) => {
+        const relay = currentPalzGatewayRelay();
+        if (!relay || !shouldInterceptModelRequest(input)) {
+            return originalFetch(input, init);
+        }
+        const nextInit = withLocatorHeaders(init, relay);
+        return relayOpenClawRequest(input, requestURL(input), nextInit, relay);
+    };
+    fetchPatched = true;
+}
+export function resolveIMSendProxy() {
+    const url = normalize(process.env.OPENCLAW_IM_SEND_PROXY_URL);
+    if (!url)
+        return null;
+    return {
+        url,
+        apiKey: normalize(process.env.CLAW_GATEWAY_API_KEY || process.env.OPENCLAW_GATEWAY_API_KEY),
+    };
+}
+exposePalzGatewayRelayGlobal();

package/src/monitor.js

@@ -167,6 +167,14 @@ export async function monitorPalzProvider(params) {
                 lastPongAt = connectedAt;
                 consecutive4002 = 0;
                 log(`palz[${accountId}]: WebSocket connected, bot_id=${config.botId}`);
+                reportPalzActivity({
+                    config,
+                    connectedAt: new Date(connectedAt),
+                    runtime,
+                    accountId,
+                }).catch((err) => {
+                    error(`palz[${accountId}]: [ACTIVITY_REPORT] unhandled error: ${err.message ?? err}`);
+                });
                 pingInterval = setInterval(() => {
                     if (ws.readyState === WebSocket.OPEN) {
                         const timeSinceLastPong = Date.now() - lastPongAt;
@@ -195,7 +203,6 @@ export async function monitorPalzProvider(params) {
                 }
             });
             ws.on("message", (data) => {
-                const receivedAt = new Date();
                 const raw = data.toString();
                 try {
                     const msg = JSON.parse(raw);
@@ -209,15 +216,6 @@ export async function monitorPalzProvider(params) {
                         try {
                             span.setAttribute("raw_message", raw);
                             log(`palz[${accountId}]: [WS_RECV] #${messageCount} full_message=${raw} traceId=${span.spanContext().traceId}`);
-                            reportPalzActivity({
-                                config,
-                                msg,
-                                receivedAt,
-                                runtime,
-                                accountId,
-                            }).catch((err) => {
-                                error(`palz[${accountId}]: [ACTIVITY_REPORT] unhandled error: ${err.message ?? err}`);
-                            });
                             // agent_id：从消息中取，缺失/空时默认为 {userId}-main
                             let messageAgentId = typeof msg.agent_id === "string" ? msg.agent_id.trim() : "";
                             if (!messageAgentId) {

package/src/send.js

@@ -6,6 +6,7 @@
  */
 import { tracer, trace, SpanStatusCode, buildTraceparentHeader } from "./tracing.js";
 import { contentPartsToOpenAIContent } from "./content.js";
+import { resolveIMSendProxy } from "./gateway-relay.js";
 const SEND_TIMEOUT_MS = 40_000;
 /**
  * IM 后端转调腾讯 IM SDK 时可能命中内容风控（敏感词），此时 HTTP 200 但 body
@@ -71,7 +72,8 @@ async function _sendToPalzIMInner(params) {
     const log = paramLog ?? console.log;
     const error = paramError ?? console.error;
     const content = normalizeContent(rawContent);
-    const url = `${config.apiBaseUrl}/bot/send`;
+    const imSendProxy = resolveIMSendProxy();
+    const url = imSendProxy?.url || `${config.apiBaseUrl}/bot/send`;
     const resolvedMsgId = msgId || nextMsgId();
     const span = trace.getActiveSpan();
     const reqBody = {
@@ -116,6 +118,9 @@ async function _sendToPalzIMInner(params) {
     if (traceparent) {
         headers["Traceparent"] = traceparent;
     }
+    if (imSendProxy?.apiKey) {
+        headers["X-API-Key"] = imSendProxy.apiKey;
+    }
     const startMs = Date.now();
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), SEND_TIMEOUT_MS);

package/tsconfig.json

@@ -0,0 +1,19 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "rootDir": "./",
+    "strict": true,                      
+    "esModuleInterop": true,             
+    "skipLibCheck": true,                
+    "resolveJsonModule": true
+  },
+  "include": [
+    "index.ts",
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}