openclaw-nim 0.0.1

package/src/outbound.ts

@@ -0,0 +1,322 @@
+import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
+import type { NimConfig } from "./types.js";
+import { sendMessageNim, splitMessageIntoChunks } from "./send.js";
+import { sendImageNim, sendFileNim, inferMessageType } from "./media.js";
+import { normalizeNimTarget } from "./targets.js";
+
+/** Default text chunk limit for NIM messages */
+const DEFAULT_TEXT_CHUNK_LIMIT = 5000;
+
+/**
+ * Outbound send result type (matching Clawdbot SDK expectations)
+ */
+export type NimOutboundResult = {
+  channel: "nim";
+  ok: boolean;
+  msgId?: string;
+  clientMsgId?: string;
+  error?: string;
+};
+
+/**
+ * Outbound message options (legacy, for backward compatibility)
+ */
+export type NimOutboundOptions = {
+  cfg: ClawdbotConfig;
+  to: string;
+  text?: string;
+  mediaPath?: string;
+};
+
+/**
+ * Target resolution result
+ */
+type TargetResolveResult =
+  | { ok: true; to: string }
+  | { ok: false; error: string };
+
+/**
+ * Resolve NIM target from various input formats.
+ * Implements the standard outbound.resolveTarget interface.
+ */
+export function resolveNimOutboundTarget(params: {
+  to?: string;
+  allowFrom?: (string | number)[];
+  mode?: "explicit" | "implicit" | "heartbeat";
+}): TargetResolveResult {
+  const { to, allowFrom, mode } = params;
+  const trimmed = to?.trim() ?? "";
+
+  // Normalize allowFrom list
+  const allowListRaw = (allowFrom ?? [])
+    .map((entry) => String(entry).trim())
+    .filter(Boolean);
+  const hasWildcard = allowListRaw.includes("*");
+  const allowList = allowListRaw
+    .filter((entry) => entry !== "*")
+    .map((entry) => normalizeNimTarget(entry))
+    .filter((entry): entry is string => Boolean(entry));
+
+  // If explicit target provided
+  if (trimmed) {
+    const normalizedTo = normalizeNimTarget(trimmed);
+    if (!normalizedTo) {
+      // Fallback to allowFrom if target is invalid
+      if ((mode === "implicit" || mode === "heartbeat") && allowList.length > 0) {
+        return { ok: true, to: allowList[0] };
+      }
+      return {
+        ok: false,
+        error: `Invalid NIM target: ${trimmed}. Provide a valid NIM account ID or configure channels.nim.allowFrom.`,
+      };
+    }
+
+    // For implicit/heartbeat mode, verify target is in allowlist
+    if (mode === "implicit" || mode === "heartbeat") {
+      if (hasWildcard || allowList.length === 0) {
+        return { ok: true, to: normalizedTo };
+      }
+      if (allowList.includes(normalizedTo)) {
+        return { ok: true, to: normalizedTo };
+      }
+      // Fallback to first allowlist entry
+      return { ok: true, to: allowList[0] };
+    }
+
+    return { ok: true, to: normalizedTo };
+  }
+
+  // No explicit target - use allowFrom
+  if (allowList.length > 0) {
+    return { ok: true, to: allowList[0] };
+  }
+
+  return {
+    ok: false,
+    error: `Missing NIM target. Provide a target ID or configure channels.nim.allowFrom.`,
+  };
+}
+
+/**
+ * Send text message through NIM channel.
+ * Implements the standard outbound.sendText interface.
+ */
+export async function sendNimOutboundText(params: {
+  to: string;
+  text: string;
+  cfg: ClawdbotConfig;
+  accountId?: string;
+}): Promise<NimOutboundResult> {
+  const { to, text, cfg } = params;
+
+  console.log(`[NIM Outbound] sendText to=${to}, textLen=${text.length}`);
+
+  try {
+    const result = await sendMessageNim({ cfg, to, text });
+
+    if (result.success) {
+      console.log(`[NIM Outbound] sendText success, msgId=${result.msgId}`);
+      return {
+        channel: "nim",
+        ok: true,
+        msgId: result.msgId,
+        clientMsgId: result.clientMsgId,
+      };
+    } else {
+      console.error(`[NIM Outbound] sendText failed: ${result.error}`);
+      return {
+        channel: "nim",
+        ok: false,
+        error: result.error,
+      };
+    }
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.error(`[NIM Outbound] sendText exception: ${errorMsg}`);
+    return {
+      channel: "nim",
+      ok: false,
+      error: errorMsg,
+    };
+  }
+}
+
+/**
+ * Send media message through NIM channel.
+ * Implements the standard outbound.sendMedia interface.
+ */
+export async function sendNimOutboundMedia(params: {
+  to: string;
+  text?: string;
+  mediaUrl?: string;
+  mediaPath?: string;
+  cfg: ClawdbotConfig;
+  accountId?: string;
+}): Promise<NimOutboundResult> {
+  const { to, text, mediaUrl, mediaPath, cfg } = params;
+  const media = mediaPath || mediaUrl;
+
+  console.log(`[NIM Outbound] sendMedia to=${to}, media=${media}, hasText=${Boolean(text)}`);
+
+  try {
+    // Send media if provided
+    if (media) {
+      const mediaType = inferMessageType(media);
+      let mediaResult;
+
+      if (mediaType === "image") {
+        mediaResult = await sendImageNim({ cfg, to, imagePath: media });
+      } else {
+        mediaResult = await sendFileNim({ cfg, to, filePath: media });
+      }
+
+      if (!mediaResult.success) {
+        console.error(`[NIM Outbound] sendMedia failed: ${mediaResult.error}`);
+        return {
+          channel: "nim",
+          ok: false,
+          error: mediaResult.error,
+        };
+      }
+
+      console.log(`[NIM Outbound] sendMedia success, msgId=${mediaResult.msgId}`);
+
+      // If no text, return media result
+      if (!text) {
+        return {
+          channel: "nim",
+          ok: true,
+          msgId: mediaResult.msgId,
+          clientMsgId: mediaResult.clientMsgId,
+        };
+      }
+    }
+
+    // Send text if provided
+    if (text) {
+      return await sendNimOutboundText({ to, text, cfg });
+    }
+
+    // Nothing to send
+    return {
+      channel: "nim",
+      ok: true,
+    };
+  } catch (error) {
+    const errorMsg = error instanceof Error ? error.message : String(error);
+    console.error(`[NIM Outbound] sendMedia exception: ${errorMsg}`);
+    return {
+      channel: "nim",
+      ok: false,
+      error: errorMsg,
+    };
+  }
+}
+
+/**
+ * NIM outbound configuration object.
+ * Conforms to Clawdbot ChannelPlugin outbound interface.
+ */
+export const nimOutboundConfig = {
+  /**
+   * Delivery mode - "gateway" means messages go through the gateway process
+   */
+  deliveryMode: "gateway" as const,
+
+  /**
+   * Text chunker function for splitting long messages
+   */
+  chunker: splitMessageIntoChunks,
+
+  /**
+   * Maximum characters per text chunk
+   */
+  textChunkLimit: DEFAULT_TEXT_CHUNK_LIMIT,
+
+  /**
+   * Resolve target address from various input formats
+   */
+  resolveTarget: resolveNimOutboundTarget,
+
+  /**
+   * Send a text message
+   */
+  sendText: async (params: {
+    to: string;
+    text: string;
+    cfg: ClawdbotConfig;
+    accountId?: string;
+    deps?: unknown;
+  }): Promise<NimOutboundResult> => {
+    return sendNimOutboundText(params);
+  },
+
+  /**
+   * Send a media message (with optional text caption)
+   */
+  sendMedia: async (params: {
+    to: string;
+    text?: string;
+    mediaUrl?: string;
+    cfg: ClawdbotConfig;
+    accountId?: string;
+    deps?: unknown;
+  }): Promise<NimOutboundResult> => {
+    return sendNimOutboundMedia({ ...params, mediaPath: params.mediaUrl });
+  },
+};
+
+// ============================================================================
+// Legacy functions for backward compatibility
+// ============================================================================
+
+/**
+ * Handle outbound messages for the NIM channel.
+ * @deprecated Use nimOutboundConfig.sendText/sendMedia instead
+ */
+export async function nimOutbound(params: NimOutboundOptions): Promise<void> {
+  const { cfg, to, text, mediaPath } = params;
+  const nimCfg = cfg.channels?.nim as NimConfig | undefined;
+
+  const targetId = normalizeNimTarget(to);
+  if (!targetId) {
+    throw new Error(`Invalid NIM target: ${to}`);
+  }
+
+  // Send media if provided
+  if (mediaPath) {
+    const result = await sendNimOutboundMedia({
+      cfg,
+      to: targetId,
+      mediaPath,
+      text,
+    });
+    if (!result.ok) {
+      throw new Error(result.error || "Failed to send media");
+    }
+    return;
+  }
+
+  // Send text if provided
+  if (text) {
+    const chunkLimit = nimCfg?.textChunkLimit ?? DEFAULT_TEXT_CHUNK_LIMIT;
+    const chunks = splitMessageIntoChunks(text, chunkLimit);
+
+    for (const chunk of chunks) {
+      const result = await sendNimOutboundText({ cfg, to: targetId, text: chunk });
+      if (!result.ok) {
+        throw new Error(result.error || "Failed to send text");
+      }
+    }
+  }
+}
+
+/**
+ * Create an outbound handler function for the NIM channel.
+ * @deprecated Use nimOutboundConfig instead
+ */
+export function createNimOutboundHandler(cfg: ClawdbotConfig) {
+  return async (params: { to: string; text?: string; mediaPath?: string }) => {
+    await nimOutbound({ cfg, ...params });
+  };
+}

package/src/probe.ts

@@ -0,0 +1,82 @@
+/**
+ * NIM Probe - 连接探测模块 (node-nim 版本)
+ */
+
+import type { NimConfig, NimProbeResult } from "./types.js";
+import { resolveNimCredentials } from "./accounts.js";
+import { createNimClient, getCachedNimClient } from "./client.js";
+
+/**
+ * 探测 NIM 连接状态（使用缓存的客户端）
+ */
+export async function probeNim(cfg: NimConfig): Promise<NimProbeResult> {
+  try {
+    const creds = resolveNimCredentials(cfg);
+    const client = getCachedNimClient(cfg);
+
+    if (client && client.loggedIn) {
+      return {
+        connected: true,
+        account: creds.account,
+        loginState: "connected",
+      };
+    }
+
+    return {
+      connected: false,
+      account: creds.account,
+      loginState: "not_connected",
+    };
+  } catch (error) {
+    return {
+      connected: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * 探测 NIM 连接状态（尝试建立连接）
+ */
+export async function probeNimWithConnect(cfg: NimConfig): Promise<NimProbeResult> {
+  try {
+    const creds = resolveNimCredentials(cfg);
+
+    // 尝试创建客户端并登录
+    const client = await createNimClient(cfg);
+    const loginSuccess = await client.login();
+
+    if (loginSuccess) {
+      return {
+        connected: true,
+        account: creds.account,
+        loginState: "connected",
+      };
+    } else {
+      return {
+        connected: false,
+        account: creds.account,
+        error: "Login failed",
+        loginState: "login_failed",
+      };
+    }
+  } catch (error) {
+    return {
+      connected: false,
+      error: error instanceof Error ? error.message : String(error),
+      loginState: "error",
+    };
+  }
+}
+
+/**
+ * 快速检查配置是否完整
+ */
+export function isNimConfigComplete(cfg: NimConfig): boolean {
+  try {
+    const creds = resolveNimCredentials(cfg);
+    return !!(creds.appKey && creds.account && creds.token);
+  } catch {
+    return false;
+  }
+}

package/src/reply-dispatcher.ts

@@ -0,0 +1,111 @@
+import type { ClawdbotConfig, RuntimeEnv } from "clawdbot/plugin-sdk";
+import type { NimConfig } from "./types.js";
+import { sendMessageNim, splitMessageIntoChunks } from "./send.js";
+import { sendImageNim, sendFileNim, inferMessageType } from "./media.js";
+import { getNimRuntime } from "./runtime.js";
+
+/**
+ * Reply payload type from Clawdbot SDK
+ */
+type ReplyPayload = {
+  text?: string;
+  mediaUrl?: string;
+  mediaUrls?: string[];
+  channelData?: Record<string, unknown>;
+};
+
+/**
+ * Create a reply dispatcher for NIM messages.
+ * Uses the Clawdbot SDK's createReplyDispatcherWithTyping for proper integration.
+ */
+export function createNimReplyDispatcher(params: {
+  cfg: ClawdbotConfig;
+  agentId: string;
+  runtime: RuntimeEnv;
+  senderId: string;
+}) {
+  const { cfg, runtime, senderId } = params;
+  const nimCfg = cfg.channels?.nim as NimConfig | undefined;
+  const log = runtime?.log ?? console.log;
+  const chunkLimit = nimCfg?.textChunkLimit ?? 4000;
+
+  // Get the core runtime which has the full channel.reply interface
+  const core = getNimRuntime();
+
+  /**
+   * Deliver function that sends a reply message to NIM.
+   * Called by the SDK dispatcher for each block/tool/final reply.
+   * @param payload - The reply payload containing text and/or media
+   */
+  const deliver = async (payload: ReplyPayload): Promise<void> => {
+    const mediaList = payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []);
+    const text = payload.text ?? "";
+
+    log(`nim: deliver called with text=${text.length} chars, media=${mediaList.length} items`);
+
+    // If no content, skip
+    if (!text && mediaList.length === 0) {
+      log(`nim: skipping empty payload`);
+      return;
+    }
+
+    try {
+      // Send media first if present
+      if (mediaList.length > 0) {
+        for (const mediaUrl of mediaList) {
+          const mediaType = inferMessageType(mediaUrl);
+          log(`nim: sending media to ${senderId}, type=${mediaType}, url=${mediaUrl}`);
+          
+          if (mediaType === "image") {
+            await sendImageNim({ cfg, to: senderId, imagePath: mediaUrl });
+          } else {
+            await sendFileNim({ cfg, to: senderId, filePath: mediaUrl });
+          }
+          log(`nim: sent media to ${senderId}`);
+        }
+      }
+
+      // Send text if present
+      if (text) {
+        const chunks = splitMessageIntoChunks(text, chunkLimit);
+        for (const chunk of chunks) {
+          await sendMessageNim({
+            cfg,
+            to: senderId,
+            text: chunk,
+          });
+          log(`nim: sent reply chunk (${chunk.length} chars) to ${senderId}`);
+        }
+      }
+    } catch (err) {
+      log(`nim: failed to send reply: ${String(err)}`);
+      throw err;
+    }
+  };
+
+  // Use the SDK's createReplyDispatcherWithTyping for proper dispatcher structure
+  const { dispatcher, replyOptions: sdkReplyOptions, markDispatchIdle } = 
+    core.channel.reply.createReplyDispatcherWithTyping({
+      deliver,
+      humanDelay: { mode: "off" },
+      onIdle: () => {
+        log(`nim: reply dispatcher is idle`);
+      },
+      onError: (err: Error) => {
+        log(`nim: reply dispatcher error: ${String(err)}`);
+      },
+    });
+
+  const replyOptions = {
+    channel: "nim" as const,
+    targetId: senderId,
+    ...sdkReplyOptions,
+  };
+
+  return {
+    dispatcher,
+    replyOptions,
+    markDispatchIdle,
+    isIdle: () => false, // The SDK dispatcher handles idle state internally
+  };
+}

package/src/runtime.ts

@@ -0,0 +1,38 @@
+import type { RuntimeEnv } from "clawdbot/plugin-sdk";
+
+/**
+ * Global runtime environment reference.
+ */
+let nimRuntime: RuntimeEnv | null = null;
+
+/**
+ * Set the NIM runtime environment.
+ */
+export function setNimRuntime(runtime: RuntimeEnv): void {
+  nimRuntime = runtime;
+}
+
+/**
+ * Get the NIM runtime environment.
+ * Throws if runtime is not set.
+ */
+export function getNimRuntime(): RuntimeEnv {
+  if (!nimRuntime) {
+    throw new Error("NIM runtime not initialized. Call setNimRuntime first.");
+  }
+  return nimRuntime;
+}
+
+/**
+ * Check if NIM runtime is initialized.
+ */
+export function isNimRuntimeInitialized(): boolean {
+  return nimRuntime !== null;
+}
+
+/**
+ * Clear the NIM runtime reference.
+ */
+export function clearNimRuntime(): void {
+  nimRuntime = null;
+}

package/src/send.ts

@@ -0,0 +1,159 @@
+/**
+ * NIM Send - 消息发送模块 (node-nim 版本)
+ */
+
+import type { ClawdbotConfig } from "clawdbot/plugin-sdk";
+import type { NimConfig, NimSendResult, NimSessionType } from "./types.js";
+import { createNimClient, getCachedNimClient } from "./client.js";
+import { normalizeNimTarget } from "./targets.js";
+
+/** 单条消息最大字符数 */
+const MAX_MESSAGE_LENGTH = 5000;
+
+/**
+ * 发送文本消息
+ */
+export async function sendMessageNim(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  text: string;
+  sessionType?: NimSessionType;
+}): Promise<NimSendResult> {
+  const { cfg, to, text, sessionType = "p2p" } = params;
+  const nimCfg = cfg.channels?.nim as NimConfig;
+  
+  if (!nimCfg) {
+    return { success: false, error: "NIM channel not configured" };
+  }
+
+  const targetId = normalizeNimTarget(to);
+  
+  try {
+    let client = getCachedNimClient(nimCfg);
+    if (!client || !client.loggedIn) {
+      client = await createNimClient(nimCfg);
+      await client.login();
+    }
+
+    return await client.sendText(targetId, text, sessionType);
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+/**
+ * 发送长消息（自动分割）
+ */
+export async function sendLongMessageNim(params: {
+  cfg: ClawdbotConfig;
+  to: string;
+  text: string;
+  sessionType?: NimSessionType;
+}): Promise<NimSendResult[]> {
+  const { cfg, to, text, sessionType = "p2p" } = params;
+  const chunks = splitMessageIntoChunks(text, MAX_MESSAGE_LENGTH);
+  const results: NimSendResult[] = [];
+
+  for (const chunk of chunks) {
+    const result = await sendMessageNim({
+      cfg,
+      to,
+      text: chunk,
+      sessionType,
+    });
+    results.push(result);
+
+    // 如果发送失败，停止发送后续消息
+    if (!result.success) {
+      break;
+    }
+
+    // 避免发送过快
+    if (chunks.length > 1) {
+      await sleep(100);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * 编辑消息（NIM 不支持真正的编辑，这里通过撤回+重发模拟）
+ * 注意：这个功能可能需要根据实际 SDK 能力调整
+ */
+export async function editMessageNim(params: {
+  cfg: ClawdbotConfig;
+  msgId: string;
+  to: string;
+  newText: string;
+  sessionType?: NimSessionType;
+}): Promise<NimSendResult> {
+  // NIM 不支持编辑消息，直接发送新消息
+  const { cfg, to, newText, sessionType = "p2p" } = params;
+  return sendMessageNim({ cfg, to, text: newText, sessionType });
+}
+
+/**
+ * 获取消息（根据消息ID）
+ * 注意：需要根据实际 node-nim SDK 能力实现
+ */
+export async function getMessageNim(params: {
+  cfg: ClawdbotConfig;
+  msgId: string;
+}): Promise<{ success: boolean; message?: unknown; error?: string }> {
+  // 暂时返回不支持
+  return {
+    success: false,
+    error: "Get message by ID is not implemented yet",
+  };
+}
+
+/**
+ * 将长文本分割成多条消息
+ */
+export function splitMessageIntoChunks(
+  text: string,
+  maxLength: number = MAX_MESSAGE_LENGTH
+): string[] {
+  if (text.length <= maxLength) {
+    return [text];
+  }
+
+  const chunks: string[] = [];
+  let remaining = text;
+
+  while (remaining.length > 0) {
+    if (remaining.length <= maxLength) {
+      chunks.push(remaining);
+      break;
+    }
+
+    // 尝试在换行符处分割
+    let splitIndex = remaining.lastIndexOf("\n", maxLength);
+    
+    // 如果没有换行符，尝试在空格处分割
+    if (splitIndex === -1 || splitIndex < maxLength * 0.5) {
+      splitIndex = remaining.lastIndexOf(" ", maxLength);
+    }
+    
+    // 如果还是找不到合适的分割点，强制在 maxLength 处分割
+    if (splitIndex === -1 || splitIndex < maxLength * 0.5) {
+      splitIndex = maxLength;
+    }
+
+    chunks.push(remaining.slice(0, splitIndex));
+    remaining = remaining.slice(splitIndex).trimStart();
+  }
+
+  return chunks;
+}
+
+/**
+ * 辅助函数：延时
+ */
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}